ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/intro.html
Revision: 1.3
Committed: Sat Jun 7 11:54:08 2003 UTC (20 years, 11 months ago) by dl
Content type: text/html
Branch: MAIN
CVS Tags: JSR166_PRELIMINARY_TEST_RELEASE_1
Changes since 1.2: +106 -142 lines
Log Message: 
More javadoc fixes

File Contents

# Content
1 <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
2 <html>
3 <head>
4 <title>JSR 166 Snapshot Introduction.</title>
5 </head>
6
7 <body bgcolor="#ffffee" vlink="#0000aa" link="#cc0000">
8 <h1>JSR 166 Snapshot Introduction.</h1>
9
10 by <a href="http://gee.cs.oswego.edu/dl">Doug Lea</a>
11 <p>
12
13 To join a mailing list discussing this JSR, go to:
14 <A HREF="http://altair.cs.oswego.edu/mailman/listinfo/concurrency-interest"> http://altair.cs.oswego.edu/mailman/listinfo/concurrency-interest</A> .
15
16 <p>
17 <em>
18 Disclaimer - This prototype is experimental code developed as part of
19 JCP JSR166 and made available to the developer community for use
20 as-is. It is not a supported product. Use it at your own risk. The
21 specification, language and implementation are subject to change as a
22 result of your feedback. Because these features have not yet been
23 approved for addition to the Java language, there is no schedule for
24 their inclusion in a product.
25 </em>
26
27 <p> Package java.util.concurrent contains utility classes commonly
28 useful in concurrent programming. Like package java.util, it includes
29 a few small standardized extensible frameworks, as well as some
30 classes that provide useful functionality and are otherwise tedious or
31 difficult to implement. JSR166 also includes a few changes and
32 additions in packages outside of java.util.concurrent: java.lang, to
33 address uncaught exceptions, and java.util to better integrate with
34 collections. Since the target release is JDK1.5, many APIs use
35 generics to parameterize on types. Here are brief descriptions of the
36 main components.
37
38 <h2>Executors</h2>
39
40 {@link java.util.concurrent.Executor} is a simple standardized
41 interface for defining custom thread-like subsystems, including thread
42 pools, asynch-IO, and lightweight task frameworks. Depending on which
43 concrete Executor class is being used, tasks may execute in a newly
44 created thread, an existing task-execution thread, or the thread
45 calling <tt>execute()</tt>, and may execute sequentially or
46 concurrently. Executors also standardize ways of calling threads that
47 compute functions returning results, via a {@link
48 java.util.concurrent.Future}. This is supported in part by defining
49 interface {@link java.util.concurrent.Callable}, the argument/result
50 analog of Runnable.
51
52 <p> {@link java.util.concurrent.ExecutorService} provides a more
53 complete framework for executing Runnables. An ExecutorService
54 manages queueing and scheduling of tasks, and allows controlled
55 shutdown. The two primary implementations of ExecutorService are
56 {@link java.util.concurrent.ThreadPoolExecutor}, a highly tunable and
57 flexible thread pool and {@link
58 java.util.concurrent.ScheduledExecutor}, which adds support for
59 delayed and periodic task execution. These, and other Executors can
60 be used in conjunction with a {@link FutureTask} to asynchronously
61 start a potentially long-running computation and query the FutureTask
62 to determine if its execution has completed, or cancel it.
63
64 <p> The {@link java.util.concurrent.Executors} class provides factory
65 methods for the most common kinds and styles of Executors, as well as
66 a few utilities methods for using them.
67
68 <h2>Queues</h2>
69
70 A basic (nonblocking) {@link java.util.Queue} interface extending
71 java.util.Collection is introduced into java.util. Existing class
72 java.util.LinkedList is adapted to support Queue, and a new
73 non-thread-safe {@link java.util.concurrent.java.util.PriorityQueue}
74 is added. The java.util.concurrent {@link
75 java.util.concurrent.LinkedQueue} class supplies an efficient
76 thread-safe non-blocking queue.
77
78 <p> Five implementations in java.util.concurrent support the extended
79 {@link java.util.concurrent.BlockingQueue} interface, that defines
80 blocking versions of put and take: {@link
81 java.util.concurrent.LinkedBlockingQueue}, {@link
82 java.util.concurrent.ArrayBlockingQueue}, {@link
83 java.util.concurrent.SynchronousQueue}, {@link
84 java.util.concurrent.PriorityBlockingQueue}, and {@link DelayQueue}.
85
86
87 <h2>Locks</h2>
88
89 The {@link java.util.concurrent.Lock} interface supports locking
90 disciplines that differ in semantics (reentrant, fair, etc), and that
91 can be used in non-block-structured contexts including hand-over-hand
92 and lock reordering algorithms. This flexibility comes at the price of
93 more awkward syntax. Implementations include {@link
94 java.util.concurrent.ReentrantLock} and {@link
95 java.util.concurrent.FairReentrantLock}.
96
97 <p> The {@link java.util.concurrent.Locks} class additionally supports
98 some common trylock-designs using builtin locks.
99
100 <p> The {@link java.util.concurrent.ReadWriteLock} interface similarly
101 defines locks that may be shared among readers but are exclusive to
102 writers. Only a single implementation, {@link
103 java.util.concurrent.ReentrantReadWriteLock}, is provided, since it
104 covers all standard usage contexts. But programmers may create their
105 own implementations to cover nonstandard requirements.
106
107 <h2>Conditions</h2>
108
109 The {@link java.util.concurrent.Condition} interface describes the
110 kinds of condition variables associated with monitors in other
111 concurrent languages, as well as pthreads-style condvars. Their
112 support reduces the need for tricky and/or inefficient solutions to
113 many classic concurrent problems. To avoid compatibility problems,
114 the names of Condition methods are different than Object versions.
115
116 <h2>Atomics</h2>
117
118 The atomic subpackage includes a small library of classes, including
119 AtomicInteger, AtomicLong, and AtomicReference that support
120 compareAndSet (CAS) and related atomic operations.
121
122 <h2>Timing</h2>
123
124 The {@link java.util.concurrent.TimeUnit} class provides multiple
125 granularities (including nanoseconds) for both accessing time and
126 performing time-out based operations.
127
128 <h2>Synchronizers</h2>
129
130 Five classes aid common special-purpose synchronization idioms.
131 {@link java.util.concurrent.Semaphore} and {@link
132 java.util.concurrent.FairSemaphore} are classic concurrency tools.
133 {@link java.util.concurrent.CountDownLatch} is very simple yet very
134 common utility for blocking until a single signal, event, or condition
135 holds. A {link CyclicBarrier} is a resettable multiway
136 synchronization point common in some styles of parallel
137 programming. An {@link java.util.concurrent.Exchanger} allows two
138 threads to exchange objects at a rendezvous point.
139
140 <h2>Concurrent Collections</h2>
141
142 This package supplies a few Collection implementations designed for
143 use in multithreaded contexts: {@link
144 java.util.concurrent.ConcurrentHashMap}, {@link
145 java.util.concurrent.CopyOnWriteArrayList}, and {@link
146 java.util.concurrent.CopyOnWriteArraySet}.
147
148 <p> Most concurrent Collection implementations (including most Queues)
149 differ from the usual java.util conventions in that their Iterators
150 provide <em>weakly consistent</em> rather than fast-fail traversal. A
151 weakly consistent iterator is thread-safe, but does not necessarily
152 freeze the collection while iterating, so it may (or may not) reflect
153 any updates since the iterator was created.
154
155 <h2>Uncaught Exception Handlers</h2>
156
157 The java.lang.Thread class is modified to allow per-thread
158 installation of handlers for uncaught exceptions. Ths optionally
159 disassociates these handlers from ThreadGroups, which has proven to be
160 too inflexible in many multithreaded programs. (Note that the
161 combination of features in JSR166 make ThreadGroups even less likely
162 to be used in most programs. Perhaps they will eventually be
163 deprecated.)
164
165 <p> Additionally, java.lang.ThreadLocal now supports a means to remove
166 a ThreadLocal, which is needed in some thread-pool and worker-thread
167 designs.
168
169 <hr>
170 <address><A HREF="http://gee.cs.oswego.edu/dl">Doug Lea</A></address>
171 </body>
172 </html>