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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.5 - (show annotations)
Thu Jun 26 04:56:11 2003 UTC (16 years, 1 month ago) by dholmes
Branch: MAIN
Changes since 1.4: +6 -4 lines
File MIME type: text/html
Fixed broken links

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 java.util.concurrent.FutureTask}
61 to asynchronously
62 start a potentially long-running computation and query the FutureTask
63 to determine if its execution has completed, or cancel it.
64
65 <p> The {@link java.util.concurrent.Executors} class provides factory
66 methods for the most common kinds and styles of Executors, as well as
67 a few utilities methods for using them.
68
69 <h2>Queues</h2>
70
71 A basic (nonblocking) {@link java.util.Queue} interface extending
72 java.util.Collection is introduced into java.util. Existing class
73 java.util.LinkedList is adapted to support Queue, and a new
74 non-thread-safe {@link java.util.PriorityQueue}
75 is added. The java.util.concurrent {@link
76 java.util.concurrent.LinkedQueue} class supplies an efficient
77 thread-safe non-blocking queue.
78
79 <p> Five implementations in java.util.concurrent support the extended
80 {@link java.util.concurrent.BlockingQueue} interface, that defines
81 blocking versions of put and take: {@link
82 java.util.concurrent.LinkedBlockingQueue}, {@link
83 java.util.concurrent.ArrayBlockingQueue}, {@link
84 java.util.concurrent.SynchronousQueue}, {@link
85 java.util.concurrent.PriorityBlockingQueue}, and
86 {@link java.util.concurrent.DelayQueue}.
87
88
89 <h2>Locks</h2>
90
91 The {@link java.util.concurrent.Lock} interface supports locking
92 disciplines that differ in semantics (reentrant, fair, etc), and that
93 can be used in non-block-structured contexts including hand-over-hand
94 and lock reordering algorithms. This flexibility comes at the price of
95 more awkward syntax. Implementations include {@link
96 java.util.concurrent.ReentrantLock} and {@link
97 java.util.concurrent.FairReentrantLock}.
98
99 <p> The {@link java.util.concurrent.Locks} class additionally supports
100 some common trylock-designs using builtin locks.
101
102 <p> The {@link java.util.concurrent.ReadWriteLock} interface similarly
103 defines locks that may be shared among readers but are exclusive to
104 writers. Only a single implementation, {@link
105 java.util.concurrent.ReentrantReadWriteLock}, is provided, since it
106 covers all standard usage contexts. But programmers may create their
107 own implementations to cover nonstandard requirements.
108
109 <h2>Conditions</h2>
110
111 The {@link java.util.concurrent.Condition} interface describes the
112 kinds of condition variables associated with monitors in other
113 concurrent languages, as well as pthreads-style condvars. Their
114 support reduces the need for tricky and/or inefficient solutions to
115 many classic concurrent problems. To avoid compatibility problems,
116 the names of Condition methods are different than Object versions.
117
118 <h2>Atomics</h2>
119
120 The atomic subpackage includes a small library of classes, including
121 AtomicInteger, AtomicLong, and AtomicReference that support
122 compareAndSet (CAS) and related atomic operations.
123
124 <h2>Timing</h2>
125
126 The {@link java.util.concurrent.TimeUnit} class provides multiple
127 granularities (including nanoseconds) for both accessing time and
128 performing time-out based operations.
129
130 <h2>Synchronizers</h2>
131
132 Five classes aid common special-purpose synchronization idioms.
133 {@link java.util.concurrent.Semaphore} and {@link
134 java.util.concurrent.FairSemaphore} are classic concurrency tools.
135 {@link java.util.concurrent.CountDownLatch} is very simple yet very
136 common utility for blocking until a single signal, event, or condition
137 holds. A {@link java.util.concurrent.CyclicBarrier} is a resettable multiway
138 synchronization point common in some styles of parallel
139 programming. An {@link java.util.concurrent.Exchanger} allows two
140 threads to exchange objects at a rendezvous point.
141
142 <h2>Concurrent Collections</h2>
143
144 This package supplies a few Collection implementations designed for
145 use in multithreaded contexts: {@link
146 java.util.concurrent.ConcurrentHashMap}, {@link
147 java.util.concurrent.CopyOnWriteArrayList}, and {@link
148 java.util.concurrent.CopyOnWriteArraySet}.
149
150 <p> Most concurrent Collection implementations (including most Queues)
151 differ from the usual java.util conventions in that their Iterators
152 provide <em>weakly consistent</em> rather than fast-fail traversal. A
153 weakly consistent iterator is thread-safe, but does not necessarily
154 freeze the collection while iterating, so it may (or may not) reflect
155 any updates since the iterator was created.
156
157 <h2>Uncaught Exception Handlers</h2>
158
159 The java.lang.Thread class is modified to allow per-thread
160 installation of handlers for uncaught exceptions. Ths optionally
161 disassociates these handlers from ThreadGroups, which has proven to be
162 too inflexible in many multithreaded programs. (Note that the
163 combination of features in JSR166 make ThreadGroups even less likely
164 to be used in most programs. Perhaps they will eventually be
165 deprecated.)
166
167 <p> Additionally, java.lang.ThreadLocal now supports a means to remove
168 a ThreadLocal, which is needed in some thread-pool and worker-thread
169 designs.
170
171 <hr>
172 <address><A HREF="http://gee.cs.oswego.edu/dl">Doug Lea</A></address>
173 </body>
174 </html>

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