jruby · Oct 5, 2015 · Oct 5, 2015
Showing with 27 additions and 13 deletions.

+26 −10 core/src/main/java/org/jruby/RubyModule.java

+1 −3 core/src/main/java/org/jruby/runtime/load/LoadService.java
diff --git a/core/src/main/java/org/jruby/RubyModule.java b/core/src/main/java/org/jruby/RubyModule.java
@@ -111,7 +111,10 @@
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReentrantLock;
 
 import static org.jruby.anno.FrameField.*;
 import static org.jruby.runtime.Visibility.*;
@@ -4279,7 +4282,7 @@ private static final class Autoload {
         // A ThreadContext which is executing autoload.
         private volatile ThreadContext ctx;
         // The lock for test-and-set the ctx.
-        private final Object ctxLock = new Object();
+        private final Lock ctxLock = new ReentrantLock();
         // An object defined for the constant while autoloading.
         private volatile IRubyObject value;
         // A method which actually requires a defined feature.
@@ -4294,28 +4297,41 @@ private static final class Autoload {
         // Returns an object for the constant if the caller is the autoloading thread.
         // Otherwise, try to start autoloading and returns the defined object by autoload.
         IRubyObject getConstant(ThreadContext ctx) {
-            synchronized (ctxLock) {
-                if (this.ctx == null) {
-                    this.ctx = ctx;
-                } else if (isSelf(ctx)) {
-                    return getValue();
+            for(int i = 10; i > 0; i--) {
+                try {
+                    if (ctxLock.tryLock(10, TimeUnit.MILLISECONDS)) {
+
+                        if (this.ctx == null) {
+                            this.ctx = ctx;
+                        } else if (isSelf(ctx)) {
+                            return getValue();
+                        }
+                        // This method needs to be synchronized for removing Autoload
+                        // from autoloadMap when it's loaded.
+                        getLoadMethod().load(ctx.runtime);
+                        return getValue();
+                    }
+                } catch (InterruptedException e) {
+                } finally {
+                    ctxLock.unlock();
                 }
-                // This method needs to be synchronized for removing Autoload
-                // from autoloadMap when it's loaded.
-                getLoadMethod().load(ctx.runtime);
             }
             return getValue();
         }
 
         // Update an object for the constant if the caller is the autoloading thread.
         boolean setConstant(ThreadContext ctx, IRubyObject newValue) {
-            synchronized(ctxLock) {
+            try{
+                ctxLock.lock();
                 boolean isSelf = isSelf(ctx);
 
                 if (isSelf) value = newValue;
 
                 return isSelf;
             }
+            finally {
+                ctxLock.unlock();
+            }
         }
 
         // Returns an object for the constant defined by autoload.

diff --git a/core/src/main/java/org/jruby/runtime/load/LoadService.java b/core/src/main/java/org/jruby/runtime/load/LoadService.java
@@ -459,9 +459,7 @@ private boolean lock(String requireName) {
 
             if (lock.isHeldByCurrentThread()) return false;
 
-            lock.lock();
-
-            return true;
+            return lock.tryLock();
         }
 
         /**