ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/concurrent/package.html
Revision: 1.6
Committed: Sat Sep 13 18:51:11 2003 UTC (20 years, 8 months ago) by dl
Content type: text/html
Branch: MAIN
Changes since 1.5: +20 -23 lines
Log Message: 
Proofreading pass -- many minor adjustments

File Contents

# User Rev Content
1 dl 1.1 <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
2     <html> <head>
3     <title>Concurrency Utilities</title>
4     </head>
5    
6     <body>
7    
8 dl 1.3 <p> Utility classes commonly useful in concurrent programming. This
9     package includes a few small standardized extensible frameworks, as
10     well as some classes that provide useful functionality and are
11     otherwise tedious or difficult to implement. Here are brief
12     descriptions of the main components. See also the <tt>locks</tt> and
13     <tt>atomic</tt> packages.
14 dl 1.1
15     <h2>Executors</h2>
16    
17     {@link java.util.concurrent.Executor} is a simple standardized
18     interface for defining custom thread-like subsystems, including thread
19     pools, asynch-IO, and lightweight task frameworks. Depending on which
20     concrete Executor class is being used, tasks may execute in a newly
21     created thread, an existing task-execution thread, or the thread
22     calling <tt>execute()</tt>, and may execute sequentially or
23     concurrently. Executors also standardize ways of calling threads that
24     compute functions returning results, via a {@link
25     java.util.concurrent.Future}. This is supported in part by defining
26     interface {@link java.util.concurrent.Callable}, the argument/result
27     analog of Runnable.
28    
29     <p> {@link java.util.concurrent.ExecutorService} provides a more
30     complete framework for executing Runnables. An ExecutorService
31     manages queueing and scheduling of tasks, and allows controlled
32     shutdown. The two primary implementations of ExecutorService are
33 dl 1.5 {@link java.util.concurrent.ThreadPoolExecutor}, a tunable and
34 dl 1.1 flexible thread pool and {@link
35     java.util.concurrent.ScheduledExecutor}, which adds support for
36     delayed and periodic task execution. These, and other Executors can
37 dl 1.5 be used in conjunction with a {@link
38     java.util.concurrent.CancellableTask} or {@link
39     java.util.concurrent.FutureTask} to asynchronously start a potentially
40 dl 1.6 long-running computation and query to determine if its execution has
41     completed, or cancel it.
42 dl 1.1
43     <p> The {@link java.util.concurrent.Executors} class provides factory
44 dl 1.2 methods for the most common kinds and configurations of Executors, as
45     well as a few utility methods for using them.
46 dl 1.1
47     <h2>Queues</h2>
48    
49 dl 1.6 The java.util.concurrent {@link
50 dl 1.1 java.util.concurrent.ConcurrentLinkedQueue} class supplies an
51 dl 1.6 efficient scalable thread-safe non-blocking FIFO queue. Five
52     implementations in java.util.concurrent support the extended {@link
53     java.util.concurrent.BlockingQueue} interface, that defines blocking
54     versions of put and take: {@link
55 dl 1.1 java.util.concurrent.LinkedBlockingQueue}, {@link
56     java.util.concurrent.ArrayBlockingQueue}, {@link
57     java.util.concurrent.SynchronousQueue}, {@link
58     java.util.concurrent.PriorityBlockingQueue}, and {@link
59 dl 1.2 java.util.concurrent.DelayQueue}. The different classes cover the most
60     common usage contexts for producer-consumer, messaging, parallel
61     tasking, and related concurrent designs.
62 dl 1.1
63    
64     <h2>Timing</h2>
65    
66     The {@link java.util.concurrent.TimeUnit} class provides multiple
67 dl 1.2 granularities (including nanoseconds) for specifying and controlling
68     time-out based operations. Nearly all other classes in the package
69     contain operations based on time-outs in addition to indefinite waits.
70 dl 1.6 In all cases that time-outs are used, the time-out specifies the
71 dholmes 1.4 minimum time that the method should wait before indicating that it
72     timed-out. The virtual machine should make a &quot;best effort&quot;
73     to detect time-outs as soon as possible after they occur. Regardless
74     of the efforts of the virtual machine, the normal scheduling
75     mechanisms, and the need to re-acquire locks in many cases, can lead
76     to an indefinite amount of time elapsing between a time-out being
77     detected and a thread actually executing again after that time-out.
78    
79 dl 1.1 <h2>Synchronizers</h2>
80    
81     Five classes aid common special-purpose synchronization idioms.
82     {@link java.util.concurrent.Semaphore} and {@link
83     java.util.concurrent.FairSemaphore} are classic concurrency tools.
84     {@link java.util.concurrent.CountDownLatch} is very simple yet very
85     common utility for blocking until a single signal, event, or condition
86     holds. A {@link java.util.concurrent.CyclicBarrier} is a resettable multiway
87     synchronization point common in some styles of parallel
88     programming. An {@link java.util.concurrent.Exchanger} allows two
89     threads to exchange objects at a rendezvous point.
90    
91     <h2>Concurrent Collections</h2>
92    
93     Besides Queues, this package supplies a few Collection implementations
94     designed for use in multithreaded contexts: {@link
95     java.util.concurrent.ConcurrentHashMap}, {@link
96     java.util.concurrent.CopyOnWriteArrayList}, and {@link
97     java.util.concurrent.CopyOnWriteArraySet}.
98    
99 dl 1.6 <p>The "Concurrent" prefix used with some classes in this package is a
100     shorthand indicating several differences from similar "synchronized"
101 dl 1.1 classes. For example <tt>java.util.Hashtable</tt> and
102     <tt>Collections.synchronizedMap(new HashMap())</tt> are
103 dl 1.6 synchronized. But {@link java.util.concurrent.ConcurrentHashMap} is
104     "concurrent". A concurrent collection is thread-safe, but not
105     governed by a single exclusion lock. In the particular case of
106     ConcurrentHashMap, it safely permits any number of concurrent reads as
107     well as a tunable number of concurrent writes. There may still be a
108     role for "synchronized" classes in some multithreaded programs -- they
109     can sometimes be useful when you need to prevent all access to a
110     collection via a single lock, at the expense of much poor
111     scalability. In all other cases, "concurrent" versions are normally
112     preferable.
113 dl 1.1
114     <p> Most concurrent Collection implementations (including most Queues)
115     also differ from the usual java.util conventions in that their Iterators
116     provide <em>weakly consistent</em> rather than fast-fail traversal. A
117     weakly consistent iterator is thread-safe, but does not necessarily
118     freeze the collection while iterating, so it may (or may not) reflect
119     any updates since the iterator was created.
120    
121     </body> </html>