-To join a mailing list discussing this JSR, go to: - http://altair.cs.oswego.edu/mailman/listinfo/concurrency-interest . - -
-
- Disclaimer - This prototype is experimental code developed as part of
- JCP JSR166 and made available to the developer community for use
- as-is. It is not a supported product. Use it at your own risk. The
- specification, language and implementation are subject to change as a
- result of your feedback. Because these features have not yet been
- approved for addition to the Java language, there is no schedule for
- their inclusion in a product.
+This is maintenance repository of JSR166 specifications. For further
+information, go to:
+http://altair.cs.oswego.edu/mailman/listinfo/concurrency-interest.
+
+ Note: The javadocs here do not include pre-existing
+java classes (for example java.lang.Thread) that were changed
+as part of the JSR166 spec. On the other hand, the javadocs here do
+include some existing java.util Collection interfaces and classes that
+are not part of the spec, but are included because some new methods
+implement or inherit from their specifications.
- JSR166 introduces package java.util.concurrent containing utility
-classes commonly useful in concurrent programming. Like package
-java.util, it includes a few small standardized extensible frameworks,
-as well as some classes that provide useful functionality and are
-otherwise tedious or difficult to implement. Descriptions of the main
-components may be found in the associated package documentation.
-
- JSR166 also includes a few changes and additions in packages
-outside of java.util.concurrent: java.lang, to address uncaught
-exceptions, and java.util to better integrate with collections. Here
-are brief descriptions.
+ JSR-166 introduces package java.util.concurrent
+containing utility classes commonly useful in concurrent
+programming. Like package java.util, it includes a few small
+standardized extensible frameworks, as well as other classes that
+provide useful functionality and are otherwise tedious or difficult to
+implement.
+
+ JSR-166 focusses on breadth, providing critical functionality
+useful across a wide range of concurrent programming styles and
+applications, ranging from low-level atomic operations, to
+customizable locks and synchronization aids, to various concurrent
+data structures, to high-level execution agents including thread
+pools. This diversity reflects the range of contexts in which
+developers of concurrent programs have been found to require or desire
+support not previously available in J2SE, which also keeping the
+resulting package small; providing only functionality that has been
+found to be worthwhile to standardize.
+
+ Descriptions and brief motivations for the main components may be
+found in the associated package documentation. JSR-166 also includes
+a few changes and additions in packages outside of
+java.util.concurrent. Here are brief descriptions.
Additionally, java.lang.ThreadLocal now supports a means to remove
+The {@link java.lang.ThreadLocal} class now supports a means to remove
a ThreadLocal, which is needed in some thread-pool and worker-thread
designs.
+
+
Queues
A basic (nonblocking) {@link java.util.Queue} interface extending
-java.util.Collection is introduced into java.util. Existing class
-java.util.LinkedList is adapted to support Queue, and a new
-non-thread-safe {@link java.util.PriorityQueue} is added.
-
-Uncaught Exception Handlers
-
-The java.lang.Thread class is modified to allow per-thread
-installation of handlers for uncaught exceptions. Ths optionally
-disassociates these handlers from ThreadGroups, which has proven to be
-too inflexible in many multithreaded programs. (Note that the
-combination of features in JSR166 make ThreadGroups even less likely
-to be used in most programs. Perhaps they will eventually be
-deprecated.)
+{@link java.util.Collection} is introduced into
+java.util. Existing class {@link java.util.LinkedList} is
+adapted to support Queue, and a new non-thread-safe {@link
+java.util.PriorityQueue} is added.
+
+Threads
+
+Three minor changes are introduced to the {@link java.lang.Thread}
+class:
+
+
+
+Timing
+
+Method nanoTime is added to {@link java.lang.System}. It
+provides a high-precision timing facility that is distinct from and
+uncoordinated with System.currentTimeMillis.
+
+Removing ThreadLocals
-
- Doug Lea