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

Comparing jsr166/src/main/java/util/concurrent/package-info.java (file contents):
Revision 1.1 by jsr166, Sun May 20 08:45:03 2007 UTC vs.
Revision 1.2 by dl, Wed Jul 29 11:55:47 2009 UTC

# Line 63 | Line 63
63   * assists in coordinating the processing of groups of
64   * asynchronous tasks.
65   *
66 + * <p>Class {@link java.util.concurrent.ForkJoinPool} provides an
67 + * Executor primarily designed for processing instances of {@link
68 + * java.util.concurrent.ForkJoinTask} and its subclasses.  These
69 + * classes employ a work-stealing scheduler that attains high
70 + * throughput for tasks conforming to restrictions that often hold in
71 + * computation-intensive parallel processing.
72 + *
73   * <h2>Queues</h2>
74   *
75   * The {@link java.util.concurrent.ConcurrentLinkedQueue} class
# Line 81 | Line 88
88   * for producer-consumer, messaging, parallel tasking, and
89   * related concurrent designs.
90   *
91 + * <p> Extended interface {@link java.util.concurrent.TransferQueue},
92 + * and implementation {@link java.util.concurrent.LinkedTransferQueue}
93 + * introduce a synchronous {@code transfer} method (along with related
94 + * features) in which a producer may optionally block awaiting its
95 + * consumer.
96 + *
97   * <p>The {@link java.util.concurrent.BlockingDeque} interface
98   * extends {@code BlockingQueue} to support both FIFO and LIFO
99   * (stack-based) operations.
# Line 108 | Line 121
121   * <h2>Synchronizers</h2>
122   *
123   * Four classes aid common special-purpose synchronization idioms.
124 < * {@link java.util.concurrent.Semaphore} is a classic concurrency tool.
125 < * {@link java.util.concurrent.CountDownLatch} is a very simple yet very
126 < * common utility for blocking until a given number of signals, events,
127 < * or conditions hold.  A {@link java.util.concurrent.CyclicBarrier} is a
128 < * resettable multiway synchronization point useful in some styles of
129 < * parallel programming.  An {@link java.util.concurrent.Exchanger} allows
130 < * two threads to exchange objects at a rendezvous point, and is useful
131 < * in several pipeline designs.
124 > * {@link java.util.concurrent.Semaphore} is a classic concurrency
125 > * tool.  {@link java.util.concurrent.CountDownLatch} is a very simple
126 > * yet very common utility for blocking until a given number of
127 > * signals, events, or conditions hold.  A {@link
128 > * java.util.concurrent.CyclicBarrier} is a resettable multiway
129 > * synchronization point useful in some styles of parallel
130 > * programming.  A {@link java.util.concurrent.Phaser} provides a more
131 > * flexible form of barrier that may be used to control phased
132 > * computation among multiple threads.  An {@link
133 > * java.util.concurrent.Exchanger} allows two threads to exchange
134 > * objects at a rendezvous point, and is useful in several pipeline
135 > * designs.
136   *
137   * <h2>Concurrent Collections</h2>
138   *
# Line 230 | Line 247
247   *   in each thread <i>happen-before</i> those subsequent to the
248   *   corresponding {@code exchange()} in another thread.
249   *
250 < *   <li>Actions prior to calling {@code CyclicBarrier.await}
250 > *   <li>Actions prior to calling {@code CyclicBarrier.await} and
251 > *   {@code Phaser.awaitAdvance} (as well as its variants)
252   *   <i>happen-before</i> actions performed by the barrier action, and
253   *   actions performed by the barrier action <i>happen-before</i> actions
254   *   subsequent to a successful return from the corresponding {@code await}

Diff Legend

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