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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines