jdk/src/share/classes/java/util/concurrent/SynchronousQueue.java
changeset 8544 225896f7b33c
parent 7976 f273c0d04215
child 9242 ef138d47df58
equal deleted inserted replaced
8543:e5ec12a932da 8544:225896f7b33c
   277             boolean isCancelled() {
   277             boolean isCancelled() {
   278                 return match == this;
   278                 return match == this;
   279             }
   279             }
   280 
   280 
   281             // Unsafe mechanics
   281             // Unsafe mechanics
   282             private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
   282             private static final sun.misc.Unsafe UNSAFE;
   283             private static final long nextOffset =
   283             private static final long matchOffset;
   284                 objectFieldOffset(UNSAFE, "next", SNode.class);
   284             private static final long nextOffset;
   285             private static final long matchOffset =
   285 
   286                 objectFieldOffset(UNSAFE, "match", SNode.class);
   286             static {
   287 
   287                 try {
       
   288                     UNSAFE = sun.misc.Unsafe.getUnsafe();
       
   289                     Class k = SNode.class;
       
   290                     matchOffset = UNSAFE.objectFieldOffset
       
   291                         (k.getDeclaredField("match"));
       
   292                     nextOffset = UNSAFE.objectFieldOffset
       
   293                         (k.getDeclaredField("next"));
       
   294                 } catch (Exception e) {
       
   295                     throw new Error(e);
       
   296                 }
       
   297             }
   288         }
   298         }
   289 
   299 
   290         /** The head (top) of the stack */
   300         /** The head (top) of the stack */
   291         volatile SNode head;
   301         volatile SNode head;
   292 
   302 
   496                     p = n;
   506                     p = n;
   497             }
   507             }
   498         }
   508         }
   499 
   509 
   500         // Unsafe mechanics
   510         // Unsafe mechanics
   501         private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
   511         private static final sun.misc.Unsafe UNSAFE;
   502         private static final long headOffset =
   512         private static final long headOffset;
   503             objectFieldOffset(UNSAFE, "head", TransferStack.class);
   513         static {
   504 
   514             try {
       
   515                 UNSAFE = sun.misc.Unsafe.getUnsafe();
       
   516                 Class k = TransferStack.class;
       
   517                 headOffset = UNSAFE.objectFieldOffset
       
   518                     (k.getDeclaredField("head"));
       
   519             } catch (Exception e) {
       
   520                 throw new Error(e);
       
   521             }
       
   522         }
   505     }
   523     }
   506 
   524 
   507     /** Dual Queue */
   525     /** Dual Queue */
   508     static final class TransferQueue extends Transferer {
   526     static final class TransferQueue extends Transferer {
   509         /*
   527         /*
   556             boolean isOffList() {
   574             boolean isOffList() {
   557                 return next == this;
   575                 return next == this;
   558             }
   576             }
   559 
   577 
   560             // Unsafe mechanics
   578             // Unsafe mechanics
   561             private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
   579             private static final sun.misc.Unsafe UNSAFE;
   562             private static final long nextOffset =
   580             private static final long itemOffset;
   563                 objectFieldOffset(UNSAFE, "next", QNode.class);
   581             private static final long nextOffset;
   564             private static final long itemOffset =
   582 
   565                 objectFieldOffset(UNSAFE, "item", QNode.class);
   583             static {
       
   584                 try {
       
   585                     UNSAFE = sun.misc.Unsafe.getUnsafe();
       
   586                     Class k = QNode.class;
       
   587                     itemOffset = UNSAFE.objectFieldOffset
       
   588                         (k.getDeclaredField("item"));
       
   589                     nextOffset = UNSAFE.objectFieldOffset
       
   590                         (k.getDeclaredField("next"));
       
   591                 } catch (Exception e) {
       
   592                     throw new Error(e);
       
   593                 }
       
   594             }
   566         }
   595         }
   567 
   596 
   568         /** Head of queue */
   597         /** Head of queue */
   569         transient volatile QNode head;
   598         transient volatile QNode head;
   570         /** Tail of queue */
   599         /** Tail of queue */
   789                 } else if (casCleanMe(null, pred))
   818                 } else if (casCleanMe(null, pred))
   790                     return;          // Postpone cleaning s
   819                     return;          // Postpone cleaning s
   791             }
   820             }
   792         }
   821         }
   793 
   822 
   794         // unsafe mechanics
   823         private static final sun.misc.Unsafe UNSAFE;
   795         private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
   824         private static final long headOffset;
   796         private static final long headOffset =
   825         private static final long tailOffset;
   797             objectFieldOffset(UNSAFE, "head", TransferQueue.class);
   826         private static final long cleanMeOffset;
   798         private static final long tailOffset =
   827         static {
   799             objectFieldOffset(UNSAFE, "tail", TransferQueue.class);
   828             try {
   800         private static final long cleanMeOffset =
   829                 UNSAFE = sun.misc.Unsafe.getUnsafe();
   801             objectFieldOffset(UNSAFE, "cleanMe", TransferQueue.class);
   830                 Class k = TransferQueue.class;
   802 
   831                 headOffset = UNSAFE.objectFieldOffset
       
   832                     (k.getDeclaredField("head"));
       
   833                 tailOffset = UNSAFE.objectFieldOffset
       
   834                     (k.getDeclaredField("tail"));
       
   835                 cleanMeOffset = UNSAFE.objectFieldOffset
       
   836                     (k.getDeclaredField("cleanMe"));
       
   837             } catch (Exception e) {
       
   838                 throw new Error(e);
       
   839             }
       
   840         }
   803     }
   841     }
   804 
   842 
   805     /**
   843     /**
   806      * The transferer. Set only in constructor, but cannot be declared
   844      * The transferer. Set only in constructor, but cannot be declared
   807      * as final without further complicating serialization.  Since
   845      * as final without further complicating serialization.  Since