ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/concurrent/ConcurrentLinkedDeque.java
(Generate patch)

Comparing jsr166/src/main/java/util/concurrent/ConcurrentLinkedDeque.java (file contents):
Revision 1.59 by jsr166, Sun Jan 4 01:06:15 2015 UTC vs.
Revision 1.60 by jsr166, Sun Jan 4 09:15:11 2015 UTC

# Line 271 | Line 271 | public class ConcurrentLinkedDeque<E>
271           * only be seen after publication via casNext or casPrev.
272           */
273          Node(E item) {
274 <            UNSAFE.putObject(this, itemOffset, item);
274 >            U.putObject(this, ITEM, item);
275          }
276  
277          boolean casItem(E cmp, E val) {
278 <            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
278 >            return U.compareAndSwapObject(this, ITEM, cmp, val);
279          }
280  
281          void lazySetNext(Node<E> val) {
282 <            UNSAFE.putOrderedObject(this, nextOffset, val);
282 >            U.putOrderedObject(this, NEXT, val);
283          }
284  
285          boolean casNext(Node<E> cmp, Node<E> val) {
286 <            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
286 >            return U.compareAndSwapObject(this, NEXT, cmp, val);
287          }
288  
289          void lazySetPrev(Node<E> val) {
290 <            UNSAFE.putOrderedObject(this, prevOffset, val);
290 >            U.putOrderedObject(this, PREV, val);
291          }
292  
293          boolean casPrev(Node<E> cmp, Node<E> val) {
294 <            return UNSAFE.compareAndSwapObject(this, prevOffset, cmp, val);
294 >            return U.compareAndSwapObject(this, PREV, cmp, val);
295          }
296  
297          // Unsafe mechanics
298  
299 <        private static final sun.misc.Unsafe UNSAFE;
300 <        private static final long prevOffset;
301 <        private static final long itemOffset;
302 <        private static final long nextOffset;
299 >        private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
300 >        private static final long PREV;
301 >        private static final long ITEM;
302 >        private static final long NEXT;
303  
304          static {
305              try {
306 <                UNSAFE = sun.misc.Unsafe.getUnsafe();
307 <                Class<?> k = Node.class;
308 <                prevOffset = UNSAFE.objectFieldOffset
309 <                    (k.getDeclaredField("prev"));
310 <                itemOffset = UNSAFE.objectFieldOffset
311 <                    (k.getDeclaredField("item"));
312 <                nextOffset = UNSAFE.objectFieldOffset
313 <                    (k.getDeclaredField("next"));
306 >                PREV = U.objectFieldOffset
307 >                    (Node.class.getDeclaredField("prev"));
308 >                ITEM = U.objectFieldOffset
309 >                    (Node.class.getDeclaredField("item"));
310 >                NEXT = U.objectFieldOffset
311 >                    (Node.class.getDeclaredField("next"));
312              } catch (ReflectiveOperationException e) {
313                  throw new Error(e);
314              }
# Line 1544 | Line 1542 | public class ConcurrentLinkedDeque<E>
1542      }
1543  
1544      private boolean casHead(Node<E> cmp, Node<E> val) {
1545 <        return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
1545 >        return U.compareAndSwapObject(this, HEAD, cmp, val);
1546      }
1547  
1548      private boolean casTail(Node<E> cmp, Node<E> val) {
1549 <        return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
1549 >        return U.compareAndSwapObject(this, TAIL, cmp, val);
1550      }
1551  
1552      // Unsafe mechanics
1553  
1554 <    private static final sun.misc.Unsafe UNSAFE;
1555 <    private static final long headOffset;
1556 <    private static final long tailOffset;
1554 >    private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
1555 >    private static final long HEAD;
1556 >    private static final long TAIL;
1557      static {
1558          PREV_TERMINATOR = new Node<Object>();
1559          PREV_TERMINATOR.next = PREV_TERMINATOR;
1560          NEXT_TERMINATOR = new Node<Object>();
1561          NEXT_TERMINATOR.prev = NEXT_TERMINATOR;
1562          try {
1563 <            UNSAFE = sun.misc.Unsafe.getUnsafe();
1564 <            Class<?> k = ConcurrentLinkedDeque.class;
1565 <            headOffset = UNSAFE.objectFieldOffset
1566 <                (k.getDeclaredField("head"));
1569 <            tailOffset = UNSAFE.objectFieldOffset
1570 <                (k.getDeclaredField("tail"));
1563 >            HEAD = U.objectFieldOffset
1564 >                (ConcurrentLinkedDeque.class.getDeclaredField("head"));
1565 >            TAIL = U.objectFieldOffset
1566 >                (ConcurrentLinkedDeque.class.getDeclaredField("tail"));
1567          } catch (ReflectiveOperationException e) {
1568              throw new Error(e);
1569          }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines