Parent Directory
| 
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 |