Lock#wait releases lock when going to sleep, even if called with lock held

Rubinius.lock counts how many times an object has been locked, and only releases the
lock when it has been unlocked an equal number of times. Therefore, if Lock#wait is
called on a Lock which was *already* locked, the call to Rubinius.unlock which occurs
before sleeping does not actually release the lock. This makes it impossible for other
threads to wake it up with #signal or #broadcast.

A solution is to make sure that #synchronize never calls Rubinius.lock on an object which
is already locked.

Author: alexdowad

lib/concurrent/synchronization/rbx_object.rb

@@ -8,13 +8,26 @@ module Synchronization
       class RbxObject < AbstractObject
         def initialize
           @__Waiters__ = []
+          @__owner__   = nil
           ensure_ivar_visibility!
         end
 
         protected
 
         def synchronize(&block)
-          Rubinius.synchronize(self, &block)
+          if @__owner__ == Thread.current
+            yield
+          else
+            Rubinius.lock(self)
+            begin
+              @__owner__ = Thread.current
+              result = yield
+            ensure
+              @__owner__ = nil
+              Rubinius.unlock(self)
+              result
+            end
+          end
         end
 
         def ns_wait(timeout = nil)

spec/concurrent/synchronization_spec.rb

@@ -1,3 +1,5 @@
+require 'timeout'
+
 module Concurrent
 
   describe Synchronization do
@@ -26,6 +28,8 @@ def wait(timeout = nil)
           synchronize { ns_wait(timeout) }
         end
 
+        public :synchronize
+
         private
 
         def ns_initialize
@@ -57,6 +61,25 @@ def ns_initialize
           expect(t.status).to eq false
           expect(t.alive?).to eq false
         end
+
+        it 'releases the lock on the current object' do
+          expect { Timeout.timeout(3) do
+            t = Thread.new { subject.wait }
+            sleep 0.1
+            expect(t.status).to eq 'sleep'
+            subject.synchronize {} # we will deadlock here if #wait doesn't release lock
+          end }.not_to raise_error
+        end
+
+        it 'can be called from within a #synchronize block' do
+          expect { Timeout.timeout(3) do
+            # #wait should release lock, even if it was already held on entry
+            t = Thread.new { subject.synchronize { subject.wait }}
+            sleep 0.1
+            expect(t.status).to eq 'sleep'
+            subject.synchronize {} # we will deadlock here if lock wasn't released
+          end }.not_to raise_error
+        end
       end
 
       describe '#synchronize' do