[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.3 - (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 :     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 : tim 1.1
68 :     <h2>Queues</h2>
69 :    
70 : dl 1.3 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 : tim 1.1
78 :     <p> Five implementations in java.util.concurrent support the extended
79 : dl 1.3 {@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 : tim 1.1
86 :    
87 :     <h2>Locks</h2>
88 :    
89 : dl 1.3 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 : tim 1.1 covers all standard usage contexts. But programmers may create their
105 :     own implementations to cover nonstandard requirements.
106 :    
107 :     <h2>Conditions</h2>
108 :    
109 : dl 1.3 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 : tim 1.1
116 : dl 1.3 <h2>Atomics</h2>
117 : tim 1.1
118 : dl 1.2 The atomic subpackage includes a small library of classes, including
119 : dl 1.3 AtomicInteger, AtomicLong, and AtomicReference that support
120 :     compareAndSet (CAS) and related atomic operations.
121 : tim 1.1
122 :     <h2>Timing</h2>
123 :    
124 : dl 1.3 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 : tim 1.1
128 :     <h2>Synchronizers</h2>
129 :    
130 :     Five classes aid common special-purpose synchronization idioms.
131 : dl 1.3 {@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 : dl 1.2 threads to exchange objects at a rendezvous point.
139 : tim 1.1
140 :     <h2>Concurrent Collections</h2>
141 :    
142 : dl 1.3 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 : tim 1.1
155 :     <h2>Uncaught Exception Handlers</h2>
156 :    
157 : dl 1.3 The java.lang.Thread class is modified to allow per-thread
158 : tim 1.1 installation of handlers for uncaught exceptions. Ths optionally
159 :     disassociates these handlers from ThreadGroups, which has proven to be
160 : dl 1.3 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 : dl 1.2
165 : dl 1.3 <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 : dl 1.2 designs.
168 : tim 1.1
169 :     <hr>
170 :     <address><A HREF="http://gee.cs.oswego.edu/dl">Doug Lea</A></address>
171 :     </body>
172 :     </html>

Doug Lea
ViewVC Help
Powered by ViewVC 1.0.8