/[cvs]/jsr166/src/main/intro.html
ViewVC logotype

Diff of /jsr166/src/main/intro.html

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.4 by dl, Tue Jun 24 14:33:52 2003 UTC revision 1.6 by dl, Thu Jun 26 10:46:55 2003 UTC
# Line 57  shutdown.  The two primary implementatio Line 57  shutdown.  The two primary implementatio
57  flexible thread pool and {@link  flexible thread pool and {@link
58  java.util.concurrent.ScheduledExecutor}, which adds support for  java.util.concurrent.ScheduledExecutor}, which adds support for
59  delayed and periodic task execution.  These, and other Executors can  delayed and periodic task execution.  These, and other Executors can
60  be used in conjunction with a {@link FutureTask} to asynchronously  be used in conjunction with a {@link java.util.concurrent.FutureTask}
61    to asynchronously
62  start a potentially long-running computation and query the FutureTask  start a potentially long-running computation and query the FutureTask
63  to determine if its execution has completed, or cancel it.  to determine if its execution has completed, or cancel it.
64    
# Line 70  a few utilities methods for using them. Line 71  a few utilities methods for using them.
71  A basic (nonblocking) {@link java.util.Queue} interface extending  A basic (nonblocking) {@link java.util.Queue} interface extending
72  java.util.Collection is introduced into java.util. Existing class  java.util.Collection is introduced into java.util. Existing class
73  java.util.LinkedList is adapted to support Queue, and a new  java.util.LinkedList is adapted to support Queue, and a new
74  non-thread-safe {@link java.util.concurrent.java.util.PriorityQueue}  non-thread-safe {@link java.util.PriorityQueue} is added.  The
75  is added.  The java.util.concurrent {@link  java.util.concurrent {@link
76  java.util.concurrent.LinkedQueue} class supplies an efficient  java.util.concurrent.ConcurrentLinkedQueue} class supplies an
77  thread-safe non-blocking queue.  efficient sclable thread-safe non-blocking FIFO queue, and {@link
78    java.util.concurrent.ConcurrentLinkedStack} provides a similar
79    non-blocking LIFO stack.
80    
81  <p> Five implementations in java.util.concurrent support the extended  <p> Five implementations in java.util.concurrent support the extended
82  {@link java.util.concurrent.BlockingQueue} interface, that defines  {@link java.util.concurrent.BlockingQueue} interface, that defines
# Line 81  blocking versions of put and take: {@lin Line 84  blocking versions of put and take: {@lin
84  java.util.concurrent.LinkedBlockingQueue}, {@link  java.util.concurrent.LinkedBlockingQueue}, {@link
85  java.util.concurrent.ArrayBlockingQueue}, {@link  java.util.concurrent.ArrayBlockingQueue}, {@link
86  java.util.concurrent.SynchronousQueue}, {@link  java.util.concurrent.SynchronousQueue}, {@link
87  java.util.concurrent.PriorityBlockingQueue}, and {@link DelayQueue}.  java.util.concurrent.PriorityBlockingQueue}, and
88    {@link java.util.concurrent.DelayQueue}.
89    
90    
91  <h2>Locks</h2>  <h2>Locks</h2>
# Line 132  Five classes aid common special-purpose Line 136  Five classes aid common special-purpose
136  java.util.concurrent.FairSemaphore} are classic concurrency tools.  java.util.concurrent.FairSemaphore} are classic concurrency tools.
137  {@link java.util.concurrent.CountDownLatch} is very simple yet very  {@link java.util.concurrent.CountDownLatch} is very simple yet very
138  common utility for blocking until a single signal, event, or condition  common utility for blocking until a single signal, event, or condition
139  holds.  A {@link CyclicBarrier} is a resettable multiway  holds.  A {@link java.util.concurrent.CyclicBarrier} is a resettable multiway
140  synchronization point common in some styles of parallel  synchronization point common in some styles of parallel
141  programming. An {@link java.util.concurrent.Exchanger} allows two  programming. An {@link java.util.concurrent.Exchanger} allows two
142  threads to exchange objects at a rendezvous point.  threads to exchange objects at a rendezvous point.
143    
144  <h2>Concurrent Collections</h2>  <h2>Concurrent Collections</h2>
145    
146  This package supplies a few Collection implementations designed for  Besides Queues, this package supplies a few Collection implementations
147  use in multithreaded contexts: {@link  designed for use in multithreaded contexts: {@link
148  java.util.concurrent.ConcurrentHashMap}, {@link  java.util.concurrent.ConcurrentHashMap}, {@link
149  java.util.concurrent.CopyOnWriteArrayList}, and {@link  java.util.concurrent.CopyOnWriteArrayList}, and {@link
150  java.util.concurrent.CopyOnWriteArraySet}.  java.util.concurrent.CopyOnWriteArraySet}.
151    
152    <p>The "Concurrent" prefix for classes is a shorthand
153    indicating several differences from similar "synchronized"
154    classes. For example <tt>java.util.Hashtable</tt> and
155    <tt>Collections.synchronizedMap(new HashMap())</tt> are
156    synchronized. But {@link
157    java.util.concurrent.ConcurrentHashMap} is "concurrent".
158    A concurrent collection (among other kinds of classes) is
159    thread-safe, but not governed by a single exclusion lock. So, in the
160    particular case of ConcurrentHashMap, it safely permits any number of
161    concurrent reads as well as a tunable number of concurrent writes.
162    There may still be a role for "synchronized" classes in some
163    multithreaded programs -- they can sometimes be useful when you need
164    to prevent ALL access to a collection via a single lock, at the
165    expense of much poor scalability. In all other cases, "concurrent"
166    versions are normally preferable.
167    
168  <p> Most concurrent Collection implementations (including most Queues)  <p> Most concurrent Collection implementations (including most Queues)
169  differ from the usual java.util conventions in that their Iterators  also differ from the usual java.util conventions in that their Iterators
170  provide <em>weakly consistent</em> rather than fast-fail traversal. A  provide <em>weakly consistent</em> rather than fast-fail traversal. A
171  weakly consistent iterator is thread-safe, but does not necessarily  weakly consistent iterator is thread-safe, but does not necessarily
172  freeze the collection while iterating, so it may (or may not) reflect  freeze the collection while iterating, so it may (or may not) reflect

Legend:
Removed from v.1.4  
changed lines
  Added in v.1.6

dl@cs.oswego.edu
ViewVC Help
Powered by ViewVC 1.1.27