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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.5 - (view) (download) (as text)

1 : tim 1.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 : dl 1.3 JCP JSR166 and made available to the developer community for use
20 : tim 1.1 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 : dl 1.3 <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 : tim 1.1
38 : dl 1.3 <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 : dholmes 1.5 be used in conjunction with a {@link java.util.concurrent.FutureTask}
61 :     to asynchronously
62 : dl 1.3 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 : tim 1.1
69 :     <h2>Queues</h2>
70 :    
71 : dl 1.3 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 : dholmes 1.5 non-thread-safe {@link java.util.PriorityQueue}
75 : dl 1.3 is added. The java.util.concurrent {@link
76 :     java.util.concurrent.LinkedQueue} class supplies an efficient
77 :     thread-safe non-blocking queue.
78 : tim 1.1
79 :     <p> Five implementations in java.util.concurrent support the extended
80 : dl 1.3 {@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 : dholmes 1.5 java.util.concurrent.PriorityBlockingQueue}, and
86 :     {@link java.util.concurrent.DelayQueue}.
87 : tim 1.1
88 :    
89 :     <h2>Locks</h2>
90 :    
91 : dl 1.3 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 : tim 1.1 covers all standard usage contexts. But programmers may create their
107 :     own implementations to cover nonstandard requirements.
108 :    
109 :     <h2>Conditions</h2>
110 :    
111 : dl 1.3 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 : tim 1.1
118 : dl 1.3 <h2>Atomics</h2>
119 : tim 1.1
120 : dl 1.2 The atomic subpackage includes a small library of classes, including
121 : dl 1.3 AtomicInteger, AtomicLong, and AtomicReference that support
122 :     compareAndSet (CAS) and related atomic operations.
123 : tim 1.1
124 :     <h2>Timing</h2>
125 :    
126 : dl 1.3 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 : tim 1.1
130 :     <h2>Synchronizers</h2>
131 :    
132 :     Five classes aid common special-purpose synchronization idioms.
133 : dl 1.3 {@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 : dholmes 1.5 holds. A {@link java.util.concurrent.CyclicBarrier} is a resettable multiway
138 : dl 1.3 synchronization point common in some styles of parallel
139 :     programming. An {@link java.util.concurrent.Exchanger} allows two
140 : dl 1.2 threads to exchange objects at a rendezvous point.
141 : tim 1.1
142 :     <h2>Concurrent Collections</h2>
143 :    
144 : dl 1.3 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 : tim 1.1
157 :     <h2>Uncaught Exception Handlers</h2>
158 :    
159 : dl 1.3 The java.lang.Thread class is modified to allow per-thread
160 : tim 1.1 installation of handlers for uncaught exceptions. Ths optionally
161 :     disassociates these handlers from ThreadGroups, which has proven to be
162 : dl 1.3 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 : dl 1.2
167 : dl 1.3 <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 : dl 1.2 designs.
170 : tim 1.1
171 :     <hr>
172 :     <address><A HREF="http://gee.cs.oswego.edu/dl">Doug Lea</A></address>
173 :     </body>
174 :     </html>

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8