Test thread interrupt during mutex lock

In jruby#9218 a user discovered that thread interrupt during
an attempt to lock a mutex may render that mutex unusable from any
other fiber, even if it did not successfully lock. This spec tries
to trigger that state by having one thread loop while triggering a
raise interrupt on another thread that repeatedly locks a mutex
from within fibers.

This may not always fail when it is broken due to the timing issues
involved in triggering the interrupt after the lock was acquired
but before interrupts have been handled by the fiber, but 10x seems
sufficient to trigger the bug on JRuby.

Author: headius

spec/ruby/core/mutex/lock_spec.rb

@@ -48,4 +48,42 @@
     f1.resume
     -> { f2.resume }.should raise_error(ThreadError, /deadlock/)
   end
+
+  it "does not raise deadlock if a fiber's attempt to lock was interrupted" do
+    lock = Mutex.new
+    main = Thread.current
+
+    t2 = nil
+    t1 = Thread.new do
+      loop do
+        # interrupt fiber below looping on synchronize
+        sleep 0.01
+        t2.raise if t2
+      end
+    end
+
+    # loop ten times to try to handle the interrupt during synchronize
+    t2 = Thread.new do
+      10.times do
+        Fiber.new do
+          begin
+            loop { lock.synchronize {} }
+          rescue RuntimeError
+          end
+        end.resume
+
+        Fiber.new do
+          ->() do
+            lock.synchronize {}
+          end.should_not raise_error(ThreadError)
+        end.resume
+      rescue RuntimeError
+        retry
+      end
+    end
+    t2.join
+  ensure
+    t1.kill rescue nil
+    t2.kill rescue nil
+  end
 end