ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/intro.html
Revision: 1.5
Committed: Thu Jun 26 04:56:11 2003 UTC (20 years, 10 months ago) by dholmes
Content type: text/html
Branch: MAIN
Changes since 1.4: +6 -4 lines
Log Message: 
Fixed broken links

File Contents

# User Rev Content
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>