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

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

# Line 426 | Line 426 | public class LinkedTransferQueue<E> exte
426  
427          // CAS methods for fields
428          final boolean casNext(Node cmp, Node val) {
429 <            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
429 >            return U.compareAndSwapObject(this, NEXT, cmp, val);
430          }
431  
432          final boolean casItem(Object cmp, Object val) {
433              // assert cmp == null || cmp.getClass() != Node.class;
434 <            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
434 >            return U.compareAndSwapObject(this, ITEM, cmp, val);
435          }
436  
437          /**
# Line 439 | Line 439 | public class LinkedTransferQueue<E> exte
439           * only be seen after publication via casNext.
440           */
441          Node(Object item, boolean isData) {
442 <            UNSAFE.putObject(this, itemOffset, item); // relaxed write
442 >            U.putObject(this, ITEM, item); // relaxed write
443              this.isData = isData;
444          }
445  
# Line 448 | Line 448 | public class LinkedTransferQueue<E> exte
448           * only after CASing head field, so uses relaxed write.
449           */
450          final void forgetNext() {
451 <            UNSAFE.putObject(this, nextOffset, this);
451 >            U.putObject(this, NEXT, this);
452          }
453  
454          /**
# Line 461 | Line 461 | public class LinkedTransferQueue<E> exte
461           * else we don't care).
462           */
463          final void forgetContents() {
464 <            UNSAFE.putObject(this, itemOffset, this);
465 <            UNSAFE.putObject(this, waiterOffset, null);
464 >            U.putObject(this, ITEM, this);
465 >            U.putObject(this, WAITER, null);
466          }
467  
468          /**
# Line 508 | Line 508 | public class LinkedTransferQueue<E> exte
508          private static final long serialVersionUID = -3375979862319811754L;
509  
510          // Unsafe mechanics
511 <        private static final sun.misc.Unsafe UNSAFE;
512 <        private static final long itemOffset;
513 <        private static final long nextOffset;
514 <        private static final long waiterOffset;
511 >        private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
512 >        private static final long ITEM;
513 >        private static final long NEXT;
514 >        private static final long WAITER;
515          static {
516              try {
517 <                UNSAFE = sun.misc.Unsafe.getUnsafe();
518 <                Class<?> k = Node.class;
519 <                itemOffset = UNSAFE.objectFieldOffset
520 <                    (k.getDeclaredField("item"));
521 <                nextOffset = UNSAFE.objectFieldOffset
522 <                    (k.getDeclaredField("next"));
523 <                waiterOffset = UNSAFE.objectFieldOffset
524 <                    (k.getDeclaredField("waiter"));
517 >                ITEM = U.objectFieldOffset
518 >                    (Node.class.getDeclaredField("item"));
519 >                NEXT = U.objectFieldOffset
520 >                    (Node.class.getDeclaredField("next"));
521 >                WAITER = U.objectFieldOffset
522 >                    (Node.class.getDeclaredField("waiter"));
523              } catch (ReflectiveOperationException e) {
524                  throw new Error(e);
525              }
# Line 539 | Line 537 | public class LinkedTransferQueue<E> exte
537  
538      // CAS methods for fields
539      private boolean casTail(Node cmp, Node val) {
540 <        return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
540 >        return U.compareAndSwapObject(this, TAIL, cmp, val);
541      }
542  
543      private boolean casHead(Node cmp, Node val) {
544 <        return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
544 >        return U.compareAndSwapObject(this, HEAD, cmp, val);
545      }
546  
547      private boolean casSweepVotes(int cmp, int val) {
548 <        return UNSAFE.compareAndSwapInt(this, sweepVotesOffset, cmp, val);
548 >        return U.compareAndSwapInt(this, SWEEPVOTES, cmp, val);
549      }
550  
551      /*
# Line 1424 | Line 1422 | public class LinkedTransferQueue<E> exte
1422  
1423      // Unsafe mechanics
1424  
1425 <    private static final sun.misc.Unsafe UNSAFE;
1426 <    private static final long headOffset;
1427 <    private static final long tailOffset;
1428 <    private static final long sweepVotesOffset;
1425 >    private static final sun.misc.Unsafe U = sun.misc.Unsafe.getUnsafe();
1426 >    private static final long HEAD;
1427 >    private static final long TAIL;
1428 >    private static final long SWEEPVOTES;
1429      static {
1430          try {
1431 <            UNSAFE = sun.misc.Unsafe.getUnsafe();
1432 <            Class<?> k = LinkedTransferQueue.class;
1433 <            headOffset = UNSAFE.objectFieldOffset
1434 <                (k.getDeclaredField("head"));
1435 <            tailOffset = UNSAFE.objectFieldOffset
1436 <                (k.getDeclaredField("tail"));
1439 <            sweepVotesOffset = UNSAFE.objectFieldOffset
1440 <                (k.getDeclaredField("sweepVotes"));
1431 >            HEAD = U.objectFieldOffset
1432 >                (LinkedTransferQueue.class.getDeclaredField("head"));
1433 >            TAIL = U.objectFieldOffset
1434 >                (LinkedTransferQueue.class.getDeclaredField("tail"));
1435 >            SWEEPVOTES = U.objectFieldOffset
1436 >                (LinkedTransferQueue.class.getDeclaredField("sweepVotes"));
1437          } catch (ReflectiveOperationException e) {
1438              throw new Error(e);
1439          }

Diff Legend

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