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

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

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

revision 1.5, Thu Jun 26 04:56:11 2003 UTC revision 1.6, Thu Jun 26 10:46:55 2003 UTC
# Line 71  Line 71 
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.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 141  Line 143 
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.5  
changed lines
  Added in v.1.6

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8