Return to interruptible lock acquisition in Mutex.

Fixes jruby#5476.

This reverts the original change from jruby#4261 that disabled lock
interrupts, and uses Task logic from RubyThread to handle the
interrupting properly.

core/src/main/java/org/jruby/ext/thread/Mutex.java

@@ -94,12 +94,28 @@ public IRubyObject lock(ThreadContext context) {
 
         // try locking without sleep status to avoid looking like blocking
         if (!thread.tryLock(lock)) {
-            // failed to acquire, proceed to sleep and block
             try {
-                thread.enterSleep();
-                thread.lock(lock);
+                context.getThread().enterSleep();
+                try {
+                    checkRelocking(context);
+                    context.getThread().executeTask(context, lock, new RubyThread.Task<ReentrantLock, Object>() {
+                        @Override
+                        public Object run(ThreadContext context, ReentrantLock reentrantLock) throws InterruptedException {
+                            reentrantLock.lockInterruptibly();
+                            return reentrantLock;
+                        }
+
+                        @Override
+                        public void wakeup(RubyThread thread, ReentrantLock reentrantLock) {
+                            thread.getNativeThread().interrupt();
+                        }
+                    });
+                } catch (InterruptedException ex) {
+                    context.pollThreadEvents();
+                    throw context.runtime.newConcurrencyError("interrupted waiting for mutex");
+                }
             } finally {
-                thread.exitSleep();
+                context.getThread().exitSleep();
             }
         }