merge revision(s) 23432:

* eval.c (rb_thread_join), ext/thread/thread.c (wake_one): adjusts
	  targets of rest waiting threads to join.  [ruby-core:23457]


git-svn-id: svn+ssh://ci.ruby-lang.org/ruby/branches/ruby_1_8_7@35942 b2dd03c8-39d4-4d8f-98ff-823fe69b080e

ChangeLog

@@ -1,3 +1,8 @@
+Wed Jun  6 15:09:00 2012  Nobuyoshi Nakada  <nobu@ruby-lang.org>
+
+	* eval.c (rb_thread_join), ext/thread/thread.c (wake_one): adjusts
+	  targets of rest waiting threads to join.  [ruby-core:23457]
+
 Wed Jun  6 14:44:13 2012  Kenta Murata  <mrkn@mrkn.jp>
 
 	* bignum.c (rb_big2dbl), test/ruby/test_bignum.rb (test_to_f):

eval.c

@@ -11566,6 +11566,16 @@ rb_thread_join(thread, limit)
     return rb_thread_join0(rb_thread_check(thread), limit);
 }
 
+void
+rb_thread_set_join(thread, join)
+    VALUE thread, join;
+{
+    rb_thread_t th = rb_thread_check(thread);
+    rb_thread_t jth = rb_thread_check(join);
+    th->wait_for = WAIT_JOIN;
+    th->join = jth;
+}
+
 
 /*
  *  call-seq:

ext/thread/thread.c

@@ -205,6 +205,16 @@ array_from_list(List const *list)
     return ary;
 }
 
+static void
+adjust_join(const List *list, VALUE new)
+{
+    extern void rb_thread_set_join _((VALUE, VALUE));
+    Entry *entry;
+    for (entry = list->entries; entry; entry = entry->next) {
+	rb_thread_set_join(entry->value, new);
+    }
+}
+
 static VALUE
 wake_thread(VALUE thread)
 {
@@ -221,7 +231,7 @@ run_thread(VALUE thread)
 }
 
 static VALUE
-wake_one(List *list)
+wake_first(List *list)
 {
     VALUE waking;
 
@@ -233,11 +243,23 @@ wake_one(List *list)
     return waking;
 }
 
+static VALUE
+wake_one(List *list)
+{
+    VALUE waking = wake_first(list);
+
+    if (!NIL_P(waking)) {
+	adjust_join(list, waking);
+    }
+
+    return waking;
+}
+
 static VALUE
 wake_all(List *list)
 {
     while (list->entries) {
-        wake_one(list);
+        wake_first(list);
     }
     return Qnil;
 }

test/thread/test_thread.rb

@@ -86,5 +86,68 @@ class TC_Thread < Test::Unit::TestCase
         assert_nothing_raised("[ruby-dev:37545]") {assert_equal(1, queue.pop)}
         assert(queue.empty?)
     end
+
+  # This test checks that a thread in Mutex#lock which is raised is
+  # completely removed from the wait_list of the mutex
+  def test_mutex_exception_handling
+    m = Mutex.new
+    m.lock
+
+    sleeping = false
+    t = Thread.new do
+      begin
+        m.lock
+      rescue
+      end
+
+      sleeping = true
+      # Keep that thread alive: if the thread returns, the test method
+      # won't be able to check that +m+ has not been taken (dead mutex
+      # owners are ignored)
+      sleep
+    end
+
+    # Wait for t to wait for the mutex and raise it
+    while true
+      sleep 0.1
+      break if t.stop?
+    end
+    t.raise ArgumentError
+    assert(t.alive? || sleeping)
+
+    # Wait for +t+ to reach the sleep
+    while true
+      sleep 0.1
+      break if t.stop?
+    end
+
+    # Now unlock. The mutex should be free, so Mutex#unlock should return nil
+    assert(! m.unlock)
+  end
+
+  def test_mutex_join
+    m = Mutex.new
+    m.lock
+    wt2 = Thread.new do
+      m.lock
+      sleep 0.5
+      m.unlock
+    end
+
+    # Ensure wt2 is waiting on m
+    sleep 0.1
+
+    wt1 = Thread.new do
+      m.lock
+      m.unlock
+    end
+    # Ensure wt1 is waiting on m
+    sleep 0.1
+
+    # Give it to wt2
+    m.unlock
+
+    assert_nothing_raised {wt1.join}
+  end
 end
 

version.h

@@ -2,7 +2,7 @@
 #define RUBY_RELEASE_DATE "2012-06-06"
 #define RUBY_VERSION_CODE 187
 #define RUBY_RELEASE_CODE 20120606
-#define RUBY_PATCHLEVEL 365
+#define RUBY_PATCHLEVEL 366
 
 #define RUBY_VERSION_MAJOR 1
 #define RUBY_VERSION_MINOR 8