src/java.base/share/classes/java/util/concurrent/ConcurrentLinkedDeque.java

Print this page
rev 12972 : 8140606: Update library code to use internal Unsafe
Reviewed-by: duke


 309         }
 310 
 311         void lazySetNext(Node<E> val) {
 312             U.putOrderedObject(this, NEXT, val);
 313         }
 314 
 315         boolean casNext(Node<E> cmp, Node<E> val) {
 316             return U.compareAndSwapObject(this, NEXT, cmp, val);
 317         }
 318 
 319         void lazySetPrev(Node<E> val) {
 320             U.putOrderedObject(this, PREV, val);
 321         }
 322 
 323         boolean casPrev(Node<E> cmp, Node<E> val) {
 324             return U.compareAndSwapObject(this, PREV, cmp, val);
 325         }
 326 
 327         // Unsafe mechanics
 328 
 329         private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
 330         private static final long PREV;
 331         private static final long ITEM;
 332         private static final long NEXT;
 333 
 334         static {
 335             try {
 336                 PREV = U.objectFieldOffset
 337                     (Node.class.getDeclaredField("prev"));
 338                 ITEM = U.objectFieldOffset
 339                     (Node.class.getDeclaredField("item"));
 340                 NEXT = U.objectFieldOffset
 341                     (Node.class.getDeclaredField("next"));
 342             } catch (ReflectiveOperationException e) {
 343                 throw new Error(e);
 344             }
 345         }
 346     }
 347 
 348     /**
 349      * Links e as first element.


1591                 h = t = newNode;
1592             else {
1593                 t.lazySetNext(newNode);
1594                 newNode.lazySetPrev(t);
1595                 t = newNode;
1596             }
1597         }
1598         initHeadTail(h, t);
1599     }
1600 
1601     private boolean casHead(Node<E> cmp, Node<E> val) {
1602         return U.compareAndSwapObject(this, HEAD, cmp, val);
1603     }
1604 
1605     private boolean casTail(Node<E> cmp, Node<E> val) {
1606         return U.compareAndSwapObject(this, TAIL, cmp, val);
1607     }
1608 
1609     // Unsafe mechanics
1610 
1611     private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
1612     private static final long HEAD;
1613     private static final long TAIL;
1614     static {
1615         PREV_TERMINATOR = new Node<Object>();
1616         PREV_TERMINATOR.next = PREV_TERMINATOR;
1617         NEXT_TERMINATOR = new Node<Object>();
1618         NEXT_TERMINATOR.prev = NEXT_TERMINATOR;
1619         try {
1620             HEAD = U.objectFieldOffset
1621                 (ConcurrentLinkedDeque.class.getDeclaredField("head"));
1622             TAIL = U.objectFieldOffset
1623                 (ConcurrentLinkedDeque.class.getDeclaredField("tail"));
1624         } catch (ReflectiveOperationException e) {
1625             throw new Error(e);
1626         }
1627     }
1628 }


 309         }
 310 
 311         void lazySetNext(Node<E> val) {
 312             U.putOrderedObject(this, NEXT, val);
 313         }
 314 
 315         boolean casNext(Node<E> cmp, Node<E> val) {
 316             return U.compareAndSwapObject(this, NEXT, cmp, val);
 317         }
 318 
 319         void lazySetPrev(Node<E> val) {
 320             U.putOrderedObject(this, PREV, val);
 321         }
 322 
 323         boolean casPrev(Node<E> cmp, Node<E> val) {
 324             return U.compareAndSwapObject(this, PREV, cmp, val);
 325         }
 326 
 327         // Unsafe mechanics
 328 
 329         private static final jdk.internal.misc.Unsafe U = jdk.internal.misc.Unsafe.getUnsafe();
 330         private static final long PREV;
 331         private static final long ITEM;
 332         private static final long NEXT;
 333 
 334         static {
 335             try {
 336                 PREV = U.objectFieldOffset
 337                     (Node.class.getDeclaredField("prev"));
 338                 ITEM = U.objectFieldOffset
 339                     (Node.class.getDeclaredField("item"));
 340                 NEXT = U.objectFieldOffset
 341                     (Node.class.getDeclaredField("next"));
 342             } catch (ReflectiveOperationException e) {
 343                 throw new Error(e);
 344             }
 345         }
 346     }
 347 
 348     /**
 349      * Links e as first element.


1591                 h = t = newNode;
1592             else {
1593                 t.lazySetNext(newNode);
1594                 newNode.lazySetPrev(t);
1595                 t = newNode;
1596             }
1597         }
1598         initHeadTail(h, t);
1599     }
1600 
1601     private boolean casHead(Node<E> cmp, Node<E> val) {
1602         return U.compareAndSwapObject(this, HEAD, cmp, val);
1603     }
1604 
1605     private boolean casTail(Node<E> cmp, Node<E> val) {
1606         return U.compareAndSwapObject(this, TAIL, cmp, val);
1607     }
1608 
1609     // Unsafe mechanics
1610 
1611     private static final jdk.internal.misc.Unsafe U = jdk.internal.misc.Unsafe.getUnsafe();
1612     private static final long HEAD;
1613     private static final long TAIL;
1614     static {
1615         PREV_TERMINATOR = new Node<Object>();
1616         PREV_TERMINATOR.next = PREV_TERMINATOR;
1617         NEXT_TERMINATOR = new Node<Object>();
1618         NEXT_TERMINATOR.prev = NEXT_TERMINATOR;
1619         try {
1620             HEAD = U.objectFieldOffset
1621                 (ConcurrentLinkedDeque.class.getDeclaredField("head"));
1622             TAIL = U.objectFieldOffset
1623                 (ConcurrentLinkedDeque.class.getDeclaredField("tail"));
1624         } catch (ReflectiveOperationException e) {
1625             throw new Error(e);
1626         }
1627     }
1628 }