# HG changeset patch # User Jaroslav Tulach # Date 1458381700 -3600 # Node ID 75ee4eca04e3ab8ab66a21519464cce786f1a06b # Parent bf15352bb2981d5a4f7ec0486514e8d939580402 Can compile java.util.concurrent.locks diff -r bf15352bb298 -r 75ee4eca04e3 rt/emul/compact/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java --- a/rt/emul/compact/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java Sat Mar 19 10:54:10 2016 +0100 +++ b/rt/emul/compact/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java Sat Mar 19 11:01:40 2016 +0100 @@ -36,8 +36,6 @@ package java.util.concurrent.locks; import java.util.*; import java.util.concurrent.*; -import java.util.concurrent.atomic.*; -import sun.misc.Unsafe; /** * A version of {@link AbstractQueuedSynchronizer} in @@ -340,7 +338,11 @@ */ protected final boolean compareAndSetState(long expect, long update) { // See below for intrinsics setup to support this - return unsafe.compareAndSwapLong(this, stateOffset, expect, update); + if (this.state == expect) { + this.state = update; + return true; + } + return false; } // Queuing utilities @@ -2043,49 +2045,25 @@ } /** - * Setup to support compareAndSet. We need to natively implement - * this here: For the sake of permitting future enhancements, we - * cannot explicitly subclass AtomicLong, which would be - * efficient and useful otherwise. So, as the lesser of evils, we - * natively implement using hotspot intrinsics API. And while we - * are at it, we do the same for other CASable fields (which could - * otherwise be done with atomic field updaters). - */ - private static final Unsafe unsafe = Unsafe.getUnsafe(); - private static final long stateOffset; - private static final long headOffset; - private static final long tailOffset; - private static final long waitStatusOffset; - private static final long nextOffset; - - static { - try { - stateOffset = unsafe.objectFieldOffset - (AbstractQueuedLongSynchronizer.class.getDeclaredField("state")); - headOffset = unsafe.objectFieldOffset - (AbstractQueuedLongSynchronizer.class.getDeclaredField("head")); - tailOffset = unsafe.objectFieldOffset - (AbstractQueuedLongSynchronizer.class.getDeclaredField("tail")); - waitStatusOffset = unsafe.objectFieldOffset - (Node.class.getDeclaredField("waitStatus")); - nextOffset = unsafe.objectFieldOffset - (Node.class.getDeclaredField("next")); - - } catch (Exception ex) { throw new Error(ex); } - } - - /** * CAS head field. Used only by enq. */ private final boolean compareAndSetHead(Node update) { - return unsafe.compareAndSwapObject(this, headOffset, null, update); + if (head == null) { + head = update; + return true; + } + return false; } /** * CAS tail field. Used only by enq. */ private final boolean compareAndSetTail(Node expect, Node update) { - return unsafe.compareAndSwapObject(this, tailOffset, expect, update); + if (tail == null) { + tail = update; + return true; + } + return false; } /** @@ -2094,8 +2072,11 @@ private static final boolean compareAndSetWaitStatus(Node node, int expect, int update) { - return unsafe.compareAndSwapInt(node, waitStatusOffset, - expect, update); + if (node.waitStatus == expect) { + node.waitStatus = update; + return true; + } + return false; } /** @@ -2104,6 +2085,10 @@ private static final boolean compareAndSetNext(Node node, Node expect, Node update) { - return unsafe.compareAndSwapObject(node, nextOffset, expect, update); + if (node.next == expect) { + node.next = update; + return true; + } + return false; } } diff -r bf15352bb298 -r 75ee4eca04e3 rt/emul/compact/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java --- a/rt/emul/compact/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java Sat Mar 19 10:54:10 2016 +0100 +++ b/rt/emul/compact/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java Sat Mar 19 11:01:40 2016 +0100 @@ -36,8 +36,6 @@ package java.util.concurrent.locks; import java.util.*; import java.util.concurrent.*; -import java.util.concurrent.atomic.*; -import sun.misc.Unsafe; /** * Provides a framework for implementing blocking locks and related @@ -563,7 +561,11 @@ */ protected final boolean compareAndSetState(int expect, int update) { // See below for intrinsics setup to support this - return unsafe.compareAndSwapInt(this, stateOffset, expect, update); + if (this.state == expect) { + this.state = update; + return true; + } + return false; } // Queuing utilities @@ -2272,41 +2274,28 @@ * are at it, we do the same for other CASable fields (which could * otherwise be done with atomic field updaters). */ - private static final Unsafe unsafe = Unsafe.getUnsafe(); - private static final long stateOffset; - private static final long headOffset; - private static final long tailOffset; - private static final long waitStatusOffset; - private static final long nextOffset; - static { - try { - stateOffset = unsafe.objectFieldOffset - (AbstractQueuedSynchronizer.class.getDeclaredField("state")); - headOffset = unsafe.objectFieldOffset - (AbstractQueuedSynchronizer.class.getDeclaredField("head")); - tailOffset = unsafe.objectFieldOffset - (AbstractQueuedSynchronizer.class.getDeclaredField("tail")); - waitStatusOffset = unsafe.objectFieldOffset - (Node.class.getDeclaredField("waitStatus")); - nextOffset = unsafe.objectFieldOffset - (Node.class.getDeclaredField("next")); - - } catch (Exception ex) { throw new Error(ex); } - } /** * CAS head field. Used only by enq. */ private final boolean compareAndSetHead(Node update) { - return unsafe.compareAndSwapObject(this, headOffset, null, update); + if (head == null) { + head = update; + return true; + } + return false; } /** * CAS tail field. Used only by enq. */ private final boolean compareAndSetTail(Node expect, Node update) { - return unsafe.compareAndSwapObject(this, tailOffset, expect, update); + if (tail == null) { + tail = update; + return true; + } + return false; } /** @@ -2315,8 +2304,11 @@ private static final boolean compareAndSetWaitStatus(Node node, int expect, int update) { - return unsafe.compareAndSwapInt(node, waitStatusOffset, - expect, update); + if (node.waitStatus == expect) { + node.waitStatus = update; + return true; + } + return false; } /** @@ -2325,6 +2317,10 @@ private static final boolean compareAndSetNext(Node node, Node expect, Node update) { - return unsafe.compareAndSwapObject(node, nextOffset, expect, update); + if (node.next == expect) { + node.next = update; + return true; + } + return false; } } diff -r bf15352bb298 -r 75ee4eca04e3 rt/emul/compact/src/main/java/java/util/concurrent/locks/LockSupport.java --- a/rt/emul/compact/src/main/java/java/util/concurrent/locks/LockSupport.java Sat Mar 19 10:54:10 2016 +0100 +++ b/rt/emul/compact/src/main/java/java/util/concurrent/locks/LockSupport.java Sat Mar 19 11:01:40 2016 +0100 @@ -34,8 +34,6 @@ */ package java.util.concurrent.locks; -import java.util.concurrent.*; -import sun.misc.Unsafe; /** @@ -120,22 +118,6 @@ public class LockSupport { private LockSupport() {} // Cannot be instantiated. - // Hotspot implementation via intrinsics API - private static final Unsafe unsafe = Unsafe.getUnsafe(); - private static final long parkBlockerOffset; - - static { - try { - parkBlockerOffset = unsafe.objectFieldOffset - (java.lang.Thread.class.getDeclaredField("parkBlocker")); - } catch (Exception ex) { throw new Error(ex); } - } - - private static void setBlocker(Thread t, Object arg) { - // Even though volatile, hotspot doesn't need a write barrier here. - unsafe.putObject(t, parkBlockerOffset, arg); - } - /** * Makes available the permit for the given thread, if it * was not already available. If the thread was blocked on @@ -148,8 +130,6 @@ * this operation has no effect */ public static void unpark(Thread thread) { - if (thread != null) - unsafe.unpark(thread); } /** @@ -181,10 +161,6 @@ * @since 1.6 */ public static void park(Object blocker) { - Thread t = Thread.currentThread(); - setBlocker(t, blocker); - unsafe.park(false, 0L); - setBlocker(t, null); } /** @@ -220,12 +196,6 @@ * @since 1.6 */ public static void parkNanos(Object blocker, long nanos) { - if (nanos > 0) { - Thread t = Thread.currentThread(); - setBlocker(t, blocker); - unsafe.park(false, nanos); - setBlocker(t, null); - } } /** @@ -262,10 +232,6 @@ * @since 1.6 */ public static void parkUntil(Object blocker, long deadline) { - Thread t = Thread.currentThread(); - setBlocker(t, blocker); - unsafe.park(true, deadline); - setBlocker(t, null); } /** @@ -281,9 +247,7 @@ * @since 1.6 */ public static Object getBlocker(Thread t) { - if (t == null) - throw new NullPointerException(); - return unsafe.getObjectVolatile(t, parkBlockerOffset); + return null; } /** @@ -312,7 +276,6 @@ * for example, the interrupt status of the thread upon return. */ public static void park() { - unsafe.park(false, 0L); } /** @@ -345,8 +308,6 @@ * @param nanos the maximum number of nanoseconds to wait */ public static void parkNanos(long nanos) { - if (nanos > 0) - unsafe.park(false, nanos); } /** @@ -380,6 +341,5 @@ * to wait until */ public static void parkUntil(long deadline) { - unsafe.park(true, deadline); } }