ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/intro.html
Revision: 1.4
Committed: Tue Jun 24 14:33:52 2003 UTC (20 years, 11 months ago) by dl
Content type: text/html
Branch: MAIN
Changes since 1.3: +1 -1 lines
Log Message: 
Fixed typo

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     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 dl 1.4 holds. A {@link CyclicBarrier} is a resettable multiway
136 dl 1.3 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>