ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/intro.html
(Generate patch)

Comparing jsr166/src/main/intro.html (file contents):
Revision 1.8 by dl, Mon Jul 14 16:35:59 2003 UTC vs.
Revision 1.15 by dl, Mon Dec 29 19:05:13 2003 UTC

# Line 1 | Line 1
1   <!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
2   <html>
3   <head>
4 <   <title>JSR 166 Snapshot Introduction.</title>
4 >   <title>JSR 166 Introduction.</title>
5    </head>
6  
7    <body bgcolor="#ffffee" vlink="#0000aa" link="#cc0000">
8 <  <h1>JSR 166 Snapshot Introduction.</h1>
8 >  <h1>JSR 166 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 < JCP JSR166 and made available to the developer community for use
20 < 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 < <p> JSR166 introduces package <tt>java.util.concurrent</tt> containing
28 < utility classes commonly useful in concurrent programming. Like
29 < package java.util, it includes a few small standardized extensible
30 < frameworks, as well as some classes that provide useful functionality
31 < and are otherwise tedious or difficult to implement. JSR-166 focusses
32 < on breadth, prviding critical functionality useful across a wide range
33 < of concurrent programming styles and applications, ranging from
34 < low-level atomic operations, to customizable locks and synchronization
35 < aids, to various concurrent data structures, to thread pools.
36 < Descriptions of the main components may be found in the associated
37 < package documentation.
38 <
39 < <p> JSR166 also includes a few changes and additions in packages
40 < outside of java.util.concurrent.  Here are brief descriptions.
13 > This is an updated version of the specification submitted for JCP Public
14 > Review.  To check for further updates, access a preliminary prototype
15 > release of main functionality, or join a mailing list discussing
16 > JSR-166, go to: <A
17 > HREF="http://altair.cs.oswego.edu/mailman/listinfo/concurrency-interest">
18 > http://altair.cs.oswego.edu/mailman/listinfo/concurrency-interest</A>.
19 >
20 > <p><em>Note: The javadocs here includes some existing java.util
21 > Collection interfaces and classes that are not part of the JSR-166
22 > spec, but are included because JSR-166 methods implement or inherit
23 > from their specifications.</em>
24 >
25 > <p> JSR-166 introduces package <tt>java.util.concurrent</tt>
26 > containing utility classes commonly useful in concurrent
27 > programming. Like package <tt>java.util</tt>, it includes a few small
28 > standardized extensible frameworks, as well as some classes that
29 > provide useful functionality and are otherwise tedious or difficult to
30 > implement.
31 >
32 > <p>JSR-166 focusses on breadth, providing critical functionality
33 > useful across a wide range of concurrent programming styles and
34 > applications, ranging from low-level atomic operations, to
35 > customizable locks and synchronization aids, to various concurrent
36 > data structures, to high-level execution agents including thread
37 > pools. This diversity reflects the range of contexts in which
38 > developers of concurrent programs have been found to require or desire
39 > support not previously available in J2SE, which also keeping the
40 > resulting package small; providing only functionality that it makes
41 > sense to standardize.
42 >
43 > <p>Descriptions and brief motivations for the main components may be
44 > found in the associated package documentation.  JSR-166 also includes
45 > a few changes and additions in packages outside of
46 > java.util.concurrent.  Here are brief descriptions.
47  
48   <h2>Queues</h2>
49  
50   A basic (nonblocking) {@link java.util.Queue} interface extending
51 < java.util.Collection is introduced into java.util. Existing class
52 < java.util.LinkedList is adapted to support Queue, and a new
53 < non-thread-safe {@link java.util.PriorityQueue} is added.
54 <
55 < <h2>Uncaught Exception Handlers</h2>
56 <
57 < The java.lang.Thread class is modified to allow per-thread
58 < installation of handlers for uncaught exceptions. Ths optionally
59 < disassociates these handlers from ThreadGroups, which has proven to be
60 < too inflexible in many multithreaded programs. (Note that the
61 < combination of features in JSR166 make ThreadGroups even less likely
62 < to be used in most programs. Perhaps they will eventually be
63 < deprecated.)
64 <
65 < <h2>High precision timing</h2>
66 <
67 < Method <tt>nanoTime</tt> is added to <tt>java.lang.System</tt>. It
68 < provides a high-precision timing facility that is distinct from
69 < and uncoordinated with <tt>System.currentTimeMillis</tt>.
51 > {@link java.util.Collection} is introduced into
52 > <tt>java.util</tt>. Existing class {@link java.util.LinkedList} is
53 > adapted to support Queue, and a new non-thread-safe {@link
54 > java.util.PriorityQueue} is added.
55 >
56 > <h2>Threads</h2>
57 >
58 > Three minor changes are introduced to the {@link java.lang.Thread}
59 > class:
60 > <ul>
61 >  <li> It now allows per-thread installation of handlers for uncaught
62 >  exceptions. Ths optionally disassociates handlers from ThreadGroups,
63 >  which has proven to be too inflexible. (Note that the combination of
64 >  features in JSR-166 make ThreadGroups even less likely to be used in
65 >  most programs. Perhaps they will eventually be deprecated.)
66 >
67 >  <li> Access checks are no longer required when a Thread interrupts
68 >  <em>itself</em>.  The <tt>interrupt</tt> method is the only way to
69 >  re-assert a thread's interruption status (and in the case of
70 >  self-interruption has no other effect than this).  The check here
71 >  previously caused unjustifiable and uncontrollable failures when
72 >  restricted code invoked library code that must reassert interruption
73 >  to correctly propagate status when encountering some
74 >  <tt>InterruptedExceptions</tt>.
75 >  <li> The <tt>destroy</tt> method, which has never been implemented,
76 >  has finally been deprecated. This is just a spec change, reflecting
77 >  the fact that that the reason it has never been implemented is that
78 >  it was undesirable and unworkable.
79 > </ul>
80 >
81 > <h2>Timing</h2>
82 >
83 > Method <tt>nanoTime</tt> is added to {@link java.lang.System}. It
84 > provides a high-precision timing facility that is distinct from and
85 > uncoordinated with <tt>System.currentTimeMillis</tt>.
86  
87   <h2>Removing ThreadLocals</h2>
88  
89 < The java.lang.ThreadLocal class now supports a means to remove a
90 < ThreadLocal, which is needed in some thread-pool and worker-thread
89 > The {@link java.lang.ThreadLocal} class now supports a means to remove
90 > a ThreadLocal, which is needed in some thread-pool and worker-thread
91   designs.
92  
93 +
94 +
95    <hr>
72  <address><A HREF="http://gee.cs.oswego.edu/dl">Doug Lea</A></address>
96   </body>
97   </html>

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines