Merge

jdk/src/share/classes/java/io/DataInput.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1995, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -66,10 +66,10 @@ package java.io;
  *          summary="Bit values and bytes">
  *     <tr>
  *       <td></td>
- *       <th id="bit">Bit Values</th>
+ *       <th id="bit_a">Bit Values</th>
  *     </tr>
  *     <tr>
- *       <th id="byte1">Byte 1</th>
+ *       <th id="byte1_a">Byte 1</th>
  *       <td>
  *         <table border="1" cellspacing="0" width="100%">
  *           <tr>
@@ -92,10 +92,10 @@ package java.io;
  *          summary="Bit values and bytes">
  *     <tr>
  *       <td></td>
- *       <th id="bit">Bit Values</th>
+ *       <th id="bit_b">Bit Values</th>
  *     </tr>
  *     <tr>
- *       <th id="byte1">Byte 1</th>
+ *       <th id="byte1_b">Byte 1</th>
  *       <td>
  *         <table border="1" cellspacing="0" width="100%">
  *           <tr>
@@ -108,7 +108,7 @@ package java.io;
  *       </td>
  *     </tr>
  *     <tr>
- *       <th id="byte2">Byte 2</th>
+ *       <th id="byte2_a">Byte 2</th>
  *       <td>
  *         <table border="1" cellspacing="0" width="100%">
  *           <tr>
@@ -131,10 +131,10 @@ package java.io;
  *          summary="Bit values and bytes">
  *     <tr>
  *       <td></td>
- *       <th id="bit">Bit Values</th>
+ *       <th id="bit_c">Bit Values</th>
  *     </tr>
  *     <tr>
- *       <th id="byte1">Byte 1</th>
+ *       <th id="byte1_c">Byte 1</th>
  *       <td>
  *         <table border="1" cellspacing="0" width="100%">
  *           <tr>
@@ -148,7 +148,7 @@ package java.io;
  *       </td>
  *     </tr>
  *     <tr>
- *       <th id="byte2">Byte 2</th>
+ *       <th id="byte2_b">Byte 2</th>
  *       <td>
  *         <table border="1" cellspacing="0" width="100%">
  *           <tr>

jdk/src/share/classes/java/io/FileInputStream.java

@@ -331,7 +331,7 @@ class FileInputStream extends InputStream
      * object associated with this file input stream.
      *
      * <p> The initial {@link java.nio.channels.FileChannel#position()
-     * </code>position<code>} of the returned channel will be equal to the
+     * position} of the returned channel will be equal to the
      * number of bytes read from the file so far.  Reading bytes from this
      * stream will increment the channel's position.  Changing the channel's
      * position, either explicitly or by reading, will change this stream's

jdk/src/share/classes/java/io/FileOutputStream.java

@@ -358,10 +358,10 @@ class FileOutputStream extends OutputStream
 
     /**
      * Returns the unique {@link java.nio.channels.FileChannel FileChannel}
-     * object associated with this file output stream. </p>
+     * object associated with this file output stream.
      *
      * <p> The initial {@link java.nio.channels.FileChannel#position()
-     * </code>position<code>} of the returned channel will be equal to the
+     * position} of the returned channel will be equal to the
      * number of bytes written to the file so far unless this stream is in
      * append mode, in which case it will be equal to the size of the file.
      * Writing bytes to this stream will increment the channel's position

jdk/src/share/classes/java/io/InputStreamReader.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1996, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -33,7 +33,7 @@ import sun.nio.cs.StreamDecoder;
 /**
  * An InputStreamReader is a bridge from byte streams to character streams: It
  * reads bytes and decodes them into characters using a specified {@link
- * java.nio.charset.Charset <code>charset</code>}.  The charset that it uses
+ * java.nio.charset.Charset charset}.  The charset that it uses
  * may be specified by name or may be given explicitly, or the platform's
  * default charset may be accepted.
  *
@@ -101,7 +101,7 @@ public class InputStreamReader extends Reader {
     }
 
     /**
-     * Creates an InputStreamReader that uses the given charset. </p>
+     * Creates an InputStreamReader that uses the given charset.
      *
      * @param  in       An InputStream
      * @param  cs       A charset
@@ -117,7 +117,7 @@ public class InputStreamReader extends Reader {
     }
 
     /**
-     * Creates an InputStreamReader that uses the given charset decoder.  </p>
+     * Creates an InputStreamReader that uses the given charset decoder.
      *
      * @param  in       An InputStream
      * @param  dec      A charset decoder

jdk/src/share/classes/java/io/OutputStreamWriter.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -33,7 +33,7 @@ import sun.nio.cs.StreamEncoder;
 /**
  * An OutputStreamWriter is a bridge from character streams to byte streams:
  * Characters written to it are encoded into bytes using a specified {@link
- * java.nio.charset.Charset <code>charset</code>}.  The charset that it uses
+ * java.nio.charset.Charset charset}.  The charset that it uses
  * may be specified by name or may be given explicitly, or the platform's
  * default charset may be accepted.
  *
@@ -86,7 +86,7 @@ public class OutputStreamWriter extends Writer {
      *
      * @param  charsetName
      *         The name of a supported
-     *         {@link java.nio.charset.Charset </code>charset<code>}
+     *         {@link java.nio.charset.Charset charset}
      *
      * @exception  UnsupportedEncodingException
      *             If the named encoding is not supported
@@ -115,7 +115,7 @@ public class OutputStreamWriter extends Writer {
     }
 
     /**
-     * Creates an OutputStreamWriter that uses the given charset. </p>
+     * Creates an OutputStreamWriter that uses the given charset.
      *
      * @param  out
      *         An OutputStream
@@ -134,7 +134,7 @@ public class OutputStreamWriter extends Writer {
     }
 
     /**
-     * Creates an OutputStreamWriter that uses the given charset encoder.  </p>
+     * Creates an OutputStreamWriter that uses the given charset encoder.
      *
      * @param  out
      *         An OutputStream

jdk/src/share/classes/java/io/PipedInputStream.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1995, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -39,7 +39,7 @@ package java.io;
  * The piped input stream contains a buffer,
  * decoupling read operations from write operations,
  * within limits.
- * A pipe is said to be <a name=BROKEN> <i>broken</i> </a> if a
+ * A pipe is said to be <a name="BROKEN"> <i>broken</i> </a> if a
  * thread that was providing data bytes to the connected
  * piped output stream is no longer alive.
  *
@@ -193,7 +193,7 @@ public class PipedInputStream extends InputStream {
      * Receives a byte of data.  This method will block if no input is
      * available.
      * @param b the byte being received
-     * @exception IOException If the pipe is <a href=#BROKEN> <code>broken</code></a>,
+     * @exception IOException If the pipe is <a href="#BROKEN"> <code>broken</code></a>,
      *          {@link #connect(java.io.PipedOutputStream) unconnected},
      *          closed, or if an I/O error occurs.
      * @since     JDK1.1
@@ -219,7 +219,7 @@ public class PipedInputStream extends InputStream {
      * @param b the buffer into which the data is received
      * @param off the start offset of the data
      * @param len the maximum number of bytes received
-     * @exception IOException If the pipe is <a href=#BROKEN> broken</a>,
+     * @exception IOException If the pipe is <a href="#BROKEN"> broken</a>,
      *           {@link #connect(java.io.PipedOutputStream) unconnected},
      *           closed,or if an I/O error occurs.
      */
@@ -298,7 +298,7 @@ public class PipedInputStream extends InputStream {
      *             stream is reached.
      * @exception  IOException  if the pipe is
      *           {@link #connect(java.io.PipedOutputStream) unconnected},
-     *           <a href=#BROKEN> <code>broken</code></a>, closed,
+     *           <a href="#BROKEN"> <code>broken</code></a>, closed,
      *           or if an I/O error occurs.
      */
     public synchronized int read()  throws IOException {
@@ -361,7 +361,7 @@ public class PipedInputStream extends InputStream {
      * @exception  IndexOutOfBoundsException If <code>off</code> is negative,
      * <code>len</code> is negative, or <code>len</code> is greater than
      * <code>b.length - off</code>
-     * @exception  IOException if the pipe is <a href=#BROKEN> <code>broken</code></a>,
+     * @exception  IOException if the pipe is <a href="#BROKEN"> <code>broken</code></a>,
      *           {@link #connect(java.io.PipedOutputStream) unconnected},
      *           closed, or if an I/O error occurs.
      */
@@ -419,7 +419,7 @@ public class PipedInputStream extends InputStream {
      *         without blocking, or {@code 0} if this input stream has been
      *         closed by invoking its {@link #close()} method, or if the pipe
      *         is {@link #connect(java.io.PipedOutputStream) unconnected}, or
-     *          <a href=#BROKEN> <code>broken</code></a>.
+     *          <a href="#BROKEN"> <code>broken</code></a>.
      *
      * @exception  IOException  if an I/O error occurs.
      * @since   JDK1.0.2

jdk/src/share/classes/java/io/RandomAccessFile.java

@@ -123,11 +123,11 @@ public class RandomAccessFile implements DataOutput, DataInput, Closeable {
      * write to, the file specified by the {@link File} argument.  A new {@link
      * FileDescriptor} object is created to represent this file connection.
      *
-     * <a name="mode"><p> The <tt>mode</tt> argument specifies the access mode
+     * <p>The <a name="mode"><tt>mode</tt></a> argument specifies the access mode
      * in which the file is to be opened.  The permitted values and their
      * meanings are:
      *
-     * <blockquote><table summary="Access mode permitted values and meanings">
+     * <table summary="Access mode permitted values and meanings">
      * <tr><th><p align="left">Value</p></th><th><p align="left">Meaning</p></th></tr>
      * <tr><td valign="top"><tt>"r"</tt></td>
      *     <td> Open for reading only.  Invoking any of the <tt>write</tt>
@@ -144,7 +144,7 @@ public class RandomAccessFile implements DataOutput, DataInput, Closeable {
      *     <td> Open for reading and writing, as with <tt>"rw"</tt>, and also
      *     require that every update to the file's content be written
      *     synchronously to the underlying storage device. </td></tr>
-     * </table></blockquote>
+     * </table>
      *
      * The <tt>"rws"</tt> and <tt>"rwd"</tt> modes work much like the {@link
      * java.nio.channels.FileChannel#force(boolean) force(boolean)} method of
@@ -158,13 +158,13 @@ public class RandomAccessFile implements DataOutput, DataInput, Closeable {
      * event of a system crash.  If the file does not reside on a local device
      * then no such guarantee is made.
      *
-     * <p> The <tt>"rwd"</tt> mode can be used to reduce the number of I/O
+     * <p>The <tt>"rwd"</tt> mode can be used to reduce the number of I/O
      * operations performed.  Using <tt>"rwd"</tt> only requires updates to the
      * file's content to be written to storage; using <tt>"rws"</tt> requires
      * updates to both the file's content and its metadata to be written, which
      * generally requires at least one more low-level I/O operation.
      *
-     * <p> If there is a security manager, its {@code checkRead} method is
+     * <p>If there is a security manager, its {@code checkRead} method is
      * called with the pathname of the {@code file} argument as its
      * argument to see if read access to the file is allowed.  If the mode
      * allows writing, the security manager's {@code checkWrite} method is
@@ -238,7 +238,7 @@ public class RandomAccessFile implements DataOutput, DataInput, Closeable {
 
     /**
      * Returns the opaque file descriptor object associated with this
-     * stream. </p>
+     * stream.
      *
      * @return     the file descriptor object associated with this stream.
      * @exception  IOException  if an I/O error occurs.

jdk/src/share/classes/java/util/LinkedList.java

@@ -1195,12 +1195,7 @@ public class LinkedList<E>
                     n = s;
                 if (n > MAX_BATCH)
                     n = MAX_BATCH;
-                Object[] a;
+                Object[] a = new Object[n];
-                try {
-                    a = new Object[n];
-                } catch (OutOfMemoryError oome) {
-                    return null;
-                }
                 int j = 0;
                 do { a[j++] = p.item; } while ((p = p.next) != null && j < n);
                 current = p;

jdk/src/share/classes/java/util/Spliterators.java

@@ -1314,12 +1314,7 @@ public final class Spliterators {
                     n = (int) s;
                 if (n > MAX_BATCH)
                     n = MAX_BATCH;
-                Object[] a;
+                Object[] a = new Object[n];
-                try {
-                    a = new Object[n];
-                } catch (OutOfMemoryError oome) {
-                    return null;
-                }
                 int j = 0;
                 do { a[j] = holder.value; } while (++j < n && tryAdvance(holder));
                 batch = j;
@@ -1429,12 +1424,7 @@ public final class Spliterators {
                     n = (int) s;
                 if (n > MAX_BATCH)
                     n = MAX_BATCH;
-                int[] a;
+                int[] a = new int[n];
-                try {
-                    a = new int[n];
-                } catch (OutOfMemoryError oome) {
-                    return null;
-                }
                 int j = 0;
                 do { a[j] = holder.value; } while (++j < n && tryAdvance(holder));
                 batch = j;
@@ -1544,12 +1534,7 @@ public final class Spliterators {
                     n = (int) s;
                 if (n > MAX_BATCH)
                     n = MAX_BATCH;
-                long[] a;
+                long[] a = new long[n];
-                try {
-                    a = new long[n];
-                } catch (OutOfMemoryError oome) {
-                    return null;
-                }
                 int j = 0;
                 do { a[j] = holder.value; } while (++j < n && tryAdvance(holder));
                 batch = j;
@@ -1659,12 +1644,7 @@ public final class Spliterators {
                     n = (int) s;
                 if (n > MAX_BATCH)
                     n = MAX_BATCH;
-                double[] a;
+                double[] a = new double[n];
-                try {
-                    a = new double[n];
-                } catch (OutOfMemoryError oome) {
-                    return null;
-                }
                 int j = 0;
                 do { a[j] = holder.value; } while (++j < n && tryAdvance(holder));
                 batch = j;
@@ -1795,12 +1775,7 @@ public final class Spliterators {
                     n = (int) s;
                 if (n > MAX_BATCH)
                     n = MAX_BATCH;
-                Object[] a;
+                Object[] a = new Object[n];
-                try {
-                    a = new Object[n];
-                } catch (OutOfMemoryError oome) {
-                    return null;
-                }
                 int j = 0;
                 do { a[j] = i.next(); } while (++j < n && i.hasNext());
                 batch = j;
@@ -1910,12 +1885,7 @@ public final class Spliterators {
                     n = (int) s;
                 if (n > MAX_BATCH)
                     n = MAX_BATCH;
-                int[] a;
+                int[] a = new int[n];
-                try {
-                    a = new int[n];
-                } catch (OutOfMemoryError oome) {
-                    return null;
-                }
                 int j = 0;
                 do { a[j] = i.nextInt(); } while (++j < n && i.hasNext());
                 batch = j;
@@ -2007,12 +1977,7 @@ public final class Spliterators {
                     n = (int) s;
                 if (n > MAX_BATCH)
                     n = MAX_BATCH;
-                long[] a;
+                long[] a = new long[n];
-                try {
-                    a = new long[n];
-                } catch (OutOfMemoryError oome) {
-                    return null;
-                }
                 int j = 0;
                 do { a[j] = i.nextLong(); } while (++j < n && i.hasNext());
                 batch = j;
@@ -2104,12 +2069,7 @@ public final class Spliterators {
                     n = (int) s;
                 if (n > MAX_BATCH)
                     n = MAX_BATCH;
-                double[] a;
+                double[] a = new double[n];
-                try {
-                    a = new double[n];
-                } catch (OutOfMemoryError oome) {
-                    return null;
-                }
                 int j = 0;
                 do { a[j] = i.nextDouble(); } while (++j < n && i.hasNext());
                 batch = j;

jdk/src/share/classes/java/util/concurrent/AbstractExecutorService.java

@@ -38,19 +38,19 @@ import java.util.*;
 
 /**
  * Provides default implementations of {@link ExecutorService}
- * execution methods. This class implements the <tt>submit</tt>,
+ * execution methods. This class implements the {@code submit},
- * <tt>invokeAny</tt> and <tt>invokeAll</tt> methods using a
+ * {@code invokeAny} and {@code invokeAll} methods using a
- * {@link RunnableFuture} returned by <tt>newTaskFor</tt>, which defaults
+ * {@link RunnableFuture} returned by {@code newTaskFor}, which defaults
  * to the {@link FutureTask} class provided in this package.  For example,
- * the implementation of <tt>submit(Runnable)</tt> creates an
+ * the implementation of {@code submit(Runnable)} creates an
- * associated <tt>RunnableFuture</tt> that is executed and
+ * associated {@code RunnableFuture} that is executed and
- * returned. Subclasses may override the <tt>newTaskFor</tt> methods
+ * returned. Subclasses may override the {@code newTaskFor} methods
- * to return <tt>RunnableFuture</tt> implementations other than
+ * to return {@code RunnableFuture} implementations other than
- * <tt>FutureTask</tt>.
+ * {@code FutureTask}.
  *
- * <p> <b>Extension example</b>. Here is a sketch of a class
+ * <p><b>Extension example</b>. Here is a sketch of a class
  * that customizes {@link ThreadPoolExecutor} to use
- * a <tt>CustomTask</tt> class instead of the default <tt>FutureTask</tt>:
+ * a {@code CustomTask} class instead of the default {@code FutureTask}:
  *  <pre> {@code
  * public class CustomThreadPoolExecutor extends ThreadPoolExecutor {
  *
@@ -71,15 +71,15 @@ import java.util.*;
 public abstract class AbstractExecutorService implements ExecutorService {
 
     /**
-     * Returns a <tt>RunnableFuture</tt> for the given runnable and default
+     * Returns a {@code RunnableFuture} for the given runnable and default
      * value.
      *
      * @param runnable the runnable task being wrapped
      * @param value the default value for the returned future
-     * @return a <tt>RunnableFuture</tt> which when run will run the
+     * @return a {@code RunnableFuture} which, when run, will run the
-     * underlying runnable and which, as a <tt>Future</tt>, will yield
+     * underlying runnable and which, as a {@code Future}, will yield
      * the given value as its result and provide for cancellation of
-     * the underlying task.
+     * the underlying task
      * @since 1.6
      */
     protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
@@ -87,13 +87,13 @@ public abstract class AbstractExecutorService implements ExecutorService {
     }
 
     /**
-     * Returns a <tt>RunnableFuture</tt> for the given callable task.
+     * Returns a {@code RunnableFuture} for the given callable task.
      *
      * @param callable the callable task being wrapped
-     * @return a <tt>RunnableFuture</tt> which when run will call the
+     * @return a {@code RunnableFuture} which, when run, will call the
-     * underlying callable and which, as a <tt>Future</tt>, will yield
+     * underlying callable and which, as a {@code Future}, will yield
      * the callable's result as its result and provide for
-     * cancellation of the underlying task.
+     * cancellation of the underlying task
      * @since 1.6
      */
     protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
@@ -144,7 +144,7 @@ public abstract class AbstractExecutorService implements ExecutorService {
         int ntasks = tasks.size();
         if (ntasks == 0)
             throw new IllegalArgumentException();
-        List<Future<T>> futures= new ArrayList<Future<T>>(ntasks);
+        ArrayList<Future<T>> futures = new ArrayList<Future<T>>(ntasks);
         ExecutorCompletionService<T> ecs =
             new ExecutorCompletionService<T>(this);
 
@@ -202,8 +202,8 @@ public abstract class AbstractExecutorService implements ExecutorService {
             throw ee;
 
         } finally {
-            for (Future<T> f : futures)
+            for (int i = 0, size = futures.size(); i < size; i++)
-                f.cancel(true);
+                futures.get(i).cancel(true);
         }
     }
 
@@ -227,7 +227,7 @@ public abstract class AbstractExecutorService implements ExecutorService {
         throws InterruptedException {
         if (tasks == null)
             throw new NullPointerException();
-        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
+        ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
         boolean done = false;
         try {
             for (Callable<T> t : tasks) {
@@ -235,7 +235,8 @@ public abstract class AbstractExecutorService implements ExecutorService {
                 futures.add(f);
                 execute(f);
             }
-            for (Future<T> f : futures) {
+            for (int i = 0, size = futures.size(); i < size; i++) {
+                Future<T> f = futures.get(i);
                 if (!f.isDone()) {
                     try {
                         f.get();
@@ -248,8 +249,8 @@ public abstract class AbstractExecutorService implements ExecutorService {
             return futures;
         } finally {
             if (!done)
-                for (Future<T> f : futures)
+                for (int i = 0, size = futures.size(); i < size; i++)
-                    f.cancel(true);
+                    futures.get(i).cancel(true);
         }
     }
 
@@ -259,25 +260,26 @@ public abstract class AbstractExecutorService implements ExecutorService {
         if (tasks == null)
             throw new NullPointerException();
         long nanos = unit.toNanos(timeout);
-        List<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
+        ArrayList<Future<T>> futures = new ArrayList<Future<T>>(tasks.size());
         boolean done = false;
         try {
             for (Callable<T> t : tasks)
                 futures.add(newTaskFor(t));
 
             final long deadline = System.nanoTime() + nanos;
+            final int size = futures.size();
 
             // Interleave time checks and calls to execute in case
             // executor doesn't have any/much parallelism.
-            Iterator<Future<T>> it = futures.iterator();
+            for (int i = 0; i < size; i++) {
-            while (it.hasNext()) {
+                execute((Runnable)futures.get(i));
-                execute((Runnable)(it.next()));
                 nanos = deadline - System.nanoTime();
                 if (nanos <= 0L)
                     return futures;
             }
 
-            for (Future<T> f : futures) {
+            for (int i = 0; i < size; i++) {
+                Future<T> f = futures.get(i);
                 if (!f.isDone()) {
                     if (nanos <= 0L)
                         return futures;
@@ -295,8 +297,8 @@ public abstract class AbstractExecutorService implements ExecutorService {
             return futures;
         } finally {
             if (!done)
-                for (Future<T> f : futures)
+                for (int i = 0, size = futures.size(); i < size; i++)
-                    f.cancel(true);
+                    futures.get(i).cancel(true);
         }
     }
 

jdk/src/share/classes/java/util/concurrent/Callable.java

@@ -38,21 +38,21 @@ package java.util.concurrent;
 /**
  * A task that returns a result and may throw an exception.
  * Implementors define a single method with no arguments called
- * <tt>call</tt>.
+ * {@code call}.
  *
- * <p>The <tt>Callable</tt> interface is similar to {@link
+ * <p>The {@code Callable} interface is similar to {@link
  * java.lang.Runnable}, in that both are designed for classes whose
  * instances are potentially executed by another thread.  A
- * <tt>Runnable</tt>, however, does not return a result and cannot
+ * {@code Runnable}, however, does not return a result and cannot
  * throw a checked exception.
  *
- * <p> The {@link Executors} class contains utility methods to
+ * <p>The {@link Executors} class contains utility methods to
- * convert from other common forms to <tt>Callable</tt> classes.
+ * convert from other common forms to {@code Callable} classes.
  *
  * @see Executor
  * @since 1.5
  * @author Doug Lea
- * @param <V> the result type of method <tt>call</tt>
+ * @param <V> the result type of method {@code call}
  */
 public interface Callable<V> {
     /**

jdk/src/share/classes/java/util/concurrent/CancellationException.java

@@ -47,12 +47,12 @@ public class CancellationException extends IllegalStateException {
     private static final long serialVersionUID = -9202173006928992231L;
 
     /**
-     * Constructs a <tt>CancellationException</tt> with no detail message.
+     * Constructs a {@code CancellationException} with no detail message.
      */
     public CancellationException() {}
 
     /**
-     * Constructs a <tt>CancellationException</tt> with the specified detail
+     * Constructs a {@code CancellationException} with the specified detail
      * message.
      *
      * @param message the detail message

jdk/src/share/classes/java/util/concurrent/CompletableFuture.java

@@ -1209,7 +1209,7 @@ public class CompletableFuture<T> implements Future<T> {
                 (r = a.result) != null &&
                 compareAndSet(0, 1)) {
                 if ((r instanceof AltResult) &&
-                    (ex = ((AltResult)r).ex) != null)  {
+                    (ex = ((AltResult)r).ex) != null) {
                     try {
                         t = fn.apply(ex);
                     } catch (Throwable rex) {
@@ -2892,7 +2892,7 @@ public class CompletableFuture<T> implements Future<T> {
         if (r != null && (d == null || d.compareAndSet(0, 1))) {
             T t = null; Throwable ex, dx = null;
             if (r instanceof AltResult) {
-                if ((ex = ((AltResult)r).ex) != null)  {
+                if ((ex = ((AltResult)r).ex) != null) {
                     try {
                         t = fn.apply(ex);
                     } catch (Throwable rex) {

jdk/src/share/classes/java/util/concurrent/CompletionService.java

@@ -38,17 +38,17 @@ package java.util.concurrent;
 /**
  * A service that decouples the production of new asynchronous tasks
  * from the consumption of the results of completed tasks.  Producers
- * <tt>submit</tt> tasks for execution. Consumers <tt>take</tt>
+ * {@code submit} tasks for execution. Consumers {@code take}
  * completed tasks and process their results in the order they
- * complete.  A <tt>CompletionService</tt> can for example be used to
+ * complete.  A {@code CompletionService} can for example be used to
- * manage asynchronous IO, in which tasks that perform reads are
+ * manage asynchronous I/O, in which tasks that perform reads are
  * submitted in one part of a program or system, and then acted upon
  * in a different part of the program when the reads complete,
  * possibly in a different order than they were requested.
  *
- * <p>Typically, a <tt>CompletionService</tt> relies on a separate
+ * <p>Typically, a {@code CompletionService} relies on a separate
  * {@link Executor} to actually execute the tasks, in which case the
- * <tt>CompletionService</tt> only manages an internal completion
+ * {@code CompletionService} only manages an internal completion
  * queue. The {@link ExecutorCompletionService} class provides an
  * implementation of this approach.
  *
@@ -80,7 +80,7 @@ public interface CompletionService<V> {
      * @param task the task to submit
      * @param result the result to return upon successful completion
      * @return a Future representing pending completion of the task,
-     *         and whose <tt>get()</tt> method will return the given
+     *         and whose {@code get()} method will return the given
      *         result value upon completion
      * @throws RejectedExecutionException if the task cannot be
      *         scheduled for execution
@@ -99,10 +99,10 @@ public interface CompletionService<V> {
 
     /**
      * Retrieves and removes the Future representing the next
-     * completed task or <tt>null</tt> if none are present.
+     * completed task, or {@code null} if none are present.
      *
      * @return the Future representing the next completed task, or
-     *         <tt>null</tt> if none are present
+     *         {@code null} if none are present
      */
     Future<V> poll();
 
@@ -112,11 +112,11 @@ public interface CompletionService<V> {
      * time if none are yet present.
      *
      * @param timeout how long to wait before giving up, in units of
-     *        <tt>unit</tt>
+     *        {@code unit}
-     * @param unit a <tt>TimeUnit</tt> determining how to interpret the
+     * @param unit a {@code TimeUnit} determining how to interpret the
-     *        <tt>timeout</tt> parameter
+     *        {@code timeout} parameter
      * @return the Future representing the next completed task or
-     *         <tt>null</tt> if the specified waiting time elapses
+     *         {@code null} if the specified waiting time elapses
      *         before one is present
      * @throws InterruptedException if interrupted while waiting
      */

jdk/src/share/classes/java/util/concurrent/CountedCompleter.java

@@ -37,14 +37,15 @@ package java.util.concurrent;
 
 /**
  * A {@link ForkJoinTask} with a completion action performed when
- * triggered and there are no remaining pending
+ * triggered and there are no remaining pending actions.
- * actions. CountedCompleters are in general more robust in the
+ * CountedCompleters are in general more robust in the
  * presence of subtask stalls and blockage than are other forms of
  * ForkJoinTasks, but are less intuitive to program.  Uses of
  * CountedCompleter are similar to those of other completion based
  * components (such as {@link java.nio.channels.CompletionHandler})
  * except that multiple <em>pending</em> completions may be necessary
- * to trigger the completion action {@link #onCompletion}, not just one.
+ * to trigger the completion action {@link #onCompletion(CountedCompleter)},
+ * not just one.
  * Unless initialized otherwise, the {@linkplain #getPendingCount pending
  * count} starts at zero, but may be (atomically) changed using
  * methods {@link #setPendingCount}, {@link #addToPendingCount}, and
@@ -69,9 +70,10 @@ package java.util.concurrent;
  * <p>A concrete CountedCompleter class must define method {@link
  * #compute}, that should in most cases (as illustrated below), invoke
  * {@code tryComplete()} once before returning. The class may also
- * optionally override method {@link #onCompletion} to perform an
+ * optionally override method {@link #onCompletion(CountedCompleter)}
- * action upon normal completion, and method {@link
+ * to perform an action upon normal completion, and method
- * #onExceptionalCompletion} to perform an action upon any exception.
+ * {@link #onExceptionalCompletion(Throwable, CountedCompleter)} to
+ * perform an action upon any exception.
  *
  * <p>CountedCompleters most often do not bear results, in which case
  * they are normally declared as {@code CountedCompleter<Void>}, and
@@ -92,13 +94,14 @@ package java.util.concurrent;
  * only as an internal helper for other computations, so its own task
  * status (as reported in methods such as {@link ForkJoinTask#isDone})
  * is arbitrary; this status changes only upon explicit invocations of
- * {@link #complete}, {@link ForkJoinTask#cancel}, {@link
+ * {@link #complete}, {@link ForkJoinTask#cancel},
- * ForkJoinTask#completeExceptionally} or upon exceptional completion
+ * {@link ForkJoinTask#completeExceptionally(Throwable)} or upon
- * of method {@code compute}. Upon any exceptional completion, the
+ * exceptional completion of method {@code compute}. Upon any
- * exception may be relayed to a task's completer (and its completer,
+ * exceptional completion, the exception may be relayed to a task's
- * and so on), if one exists and it has not otherwise already
+ * completer (and its completer, and so on), if one exists and it has
- * completed. Similarly, cancelling an internal CountedCompleter has
+ * not otherwise already completed. Similarly, cancelling an internal
- * only a local effect on that completer, so is not often useful.
+ * CountedCompleter has only a local effect on that completer, so is
+ * not often useful.
  *
  * <p><b>Sample Usages.</b>
  *
@@ -125,8 +128,8 @@ package java.util.concurrent;
  * improve load balancing. In the recursive case, the second of each
  * pair of subtasks to finish triggers completion of its parent
  * (because no result combination is performed, the default no-op
- * implementation of method {@code onCompletion} is not overridden). A
+ * implementation of method {@code onCompletion} is not overridden).
- * static utility method sets up the base task and invokes it
+ * A static utility method sets up the base task and invokes it
  * (here, implicitly using the {@link ForkJoinPool#commonPool()}).
  *
  * <pre> {@code
@@ -181,12 +184,11 @@ package java.util.concurrent;
  *   }
  * }</pre>
  *
- * As a further improvement, notice that the left task need not even
+ * As a further improvement, notice that the left task need not even exist.
- * exist.  Instead of creating a new one, we can iterate using the
+ * Instead of creating a new one, we can iterate using the original task,
- * original task, and add a pending count for each fork. Additionally,
+ * and add a pending count for each fork.  Additionally, because no task
- * because no task in this tree implements an {@link #onCompletion}
+ * in this tree implements an {@link #onCompletion(CountedCompleter)} method,
- * method, {@code tryComplete()} can be replaced with {@link
+ * {@code tryComplete()} can be replaced with {@link #propagateCompletion}.
- * #propagateCompletion}.
  *
  * <pre> {@code
  * class ForEach<E> ...
@@ -253,7 +255,7 @@ package java.util.concurrent;
  *   public static <E> E search(E[] array) {
  *       return new Searcher<E>(null, array, new AtomicReference<E>(), 0, array.length).invoke();
  *   }
- *}}</pre>
+ * }}</pre>
  *
  * In this example, as well as others in which tasks have no other
  * effects except to compareAndSet a common result, the trailing
@@ -264,7 +266,7 @@ package java.util.concurrent;
  *
  * <p><b>Recording subtasks.</b> CountedCompleter tasks that combine
  * results of multiple subtasks usually need to access these results
- * in method {@link #onCompletion}. As illustrated in the following
+ * in method {@link #onCompletion(CountedCompleter)}. As illustrated in the following
  * class (that performs a simplified form of map-reduce where mappings
  * and reductions are all of type {@code E}), one way to do this in
  * divide and conquer designs is to have each subtask record its
@@ -365,7 +367,7 @@ package java.util.concurrent;
  *     while (h - l >= 2) {
  *       int mid = (l + h) >>> 1;
  *       addToPendingCount(1);
- *       (forks = new MapReducer(this, array, mapper, reducer, mid, h, forks)).fork;
+ *       (forks = new MapReducer(this, array, mapper, reducer, mid, h, forks)).fork();
  *       h = mid;
  *     }
  *     if (h > l)
@@ -386,7 +388,7 @@ package java.util.concurrent;
  *
  * <p><b>Triggers.</b> Some CountedCompleters are themselves never
  * forked, but instead serve as bits of plumbing in other designs;
- * including those in which the completion of one of more async tasks
+ * including those in which the completion of one or more async tasks
  * triggers another async task. For example:
  *
  * <pre> {@code
@@ -460,27 +462,28 @@ public abstract class CountedCompleter<T> extends ForkJoinTask<T> {
      * (and/or links to other results) to combine.
      *
      * @param caller the task invoking this method (which may
-     * be this task itself).
+     * be this task itself)
      */
     public void onCompletion(CountedCompleter<?> caller) {
     }
 
     /**
-     * Performs an action when method {@link #completeExceptionally}
+     * Performs an action when method {@link
-     * is invoked or method {@link #compute} throws an exception, and
+     * #completeExceptionally(Throwable)} is invoked or method {@link
-     * this task has not otherwise already completed normally. On
+     * #compute} throws an exception, and this task has not already
-     * entry to this method, this task {@link
+     * otherwise completed normally. On entry to this method, this task
-     * ForkJoinTask#isCompletedAbnormally}.  The return value of this
+     * {@link ForkJoinTask#isCompletedAbnormally}.  The return value
-     * method controls further propagation: If {@code true} and this
+     * of this method controls further propagation: If {@code true}
-     * task has a completer, then this completer is also completed
+     * and this task has a completer that has not completed, then that
-     * exceptionally.  The default implementation of this method does
+     * completer is also completed exceptionally, with the same
-     * nothing except return {@code true}.
+     * exception as this completer.  The default implementation of
+     * this method does nothing except return {@code true}.
      *
      * @param ex the exception
      * @param caller the task invoking this method (which may
-     * be this task itself).
+     * be this task itself)
-     * @return true if this exception should be propagated to this
+     * @return {@code true} if this exception should be propagated to this
-     * task's completer, if one exists.
+     * task's completer, if one exists
      */
     public boolean onExceptionalCompletion(Throwable ex, CountedCompleter<?> caller) {
         return true;
@@ -520,8 +523,7 @@ public abstract class CountedCompleter<T> extends ForkJoinTask<T> {
      * @param delta the value to add
      */
     public final void addToPendingCount(int delta) {
-        int c; // note: can replace with intrinsic in jdk8
+        U.getAndAddInt(this, PENDING, delta);
-        do {} while (!U.compareAndSwapInt(this, PENDING, c = pending, c+delta));
     }
 
     /**
@@ -530,7 +532,7 @@ public abstract class CountedCompleter<T> extends ForkJoinTask<T> {
      *
      * @param expected the expected value
      * @param count the new value
-     * @return true if successful
+     * @return {@code true} if successful
      */
     public final boolean compareAndSetPendingCount(int expected, int count) {
         return U.compareAndSwapInt(this, PENDING, expected, count);
@@ -564,9 +566,9 @@ public abstract class CountedCompleter<T> extends ForkJoinTask<T> {
 
     /**
      * If the pending count is nonzero, decrements the count;
-     * otherwise invokes {@link #onCompletion} and then similarly
+     * otherwise invokes {@link #onCompletion(CountedCompleter)}
-     * tries to complete this task's completer, if one exists,
+     * and then similarly tries to complete this task's completer,
-     * else marks this task as complete.
+     * if one exists, else marks this task as complete.
      */
     public final void tryComplete() {
         CountedCompleter<?> a = this, s = a;
@@ -585,12 +587,12 @@ public abstract class CountedCompleter<T> extends ForkJoinTask<T> {
 
     /**
      * Equivalent to {@link #tryComplete} but does not invoke {@link
-     * #onCompletion} along the completion path: If the pending count
+     * #onCompletion(CountedCompleter)} along the completion path:
-     * is nonzero, decrements the count; otherwise, similarly tries to
+     * If the pending count is nonzero, decrements the count;
-     * complete this task's completer, if one exists, else marks this
+     * otherwise, similarly tries to complete this task's completer, if
-     * task as complete. This method may be useful in cases where
+     * one exists, else marks this task as complete. This method may be
-     * {@code onCompletion} should not, or need not, be invoked for
+     * useful in cases where {@code onCompletion} should not, or need
-     * each completer in a computation.
+     * not, be invoked for each completer in a computation.
      */
     public final void propagateCompletion() {
         CountedCompleter<?> a = this, s = a;
@@ -607,13 +609,15 @@ public abstract class CountedCompleter<T> extends ForkJoinTask<T> {
     }
 
     /**
-     * Regardless of pending count, invokes {@link #onCompletion},
+     * Regardless of pending count, invokes
-     * marks this task as complete and further triggers {@link
+     * {@link #onCompletion(CountedCompleter)}, marks this task as
-     * #tryComplete} on this task's completer, if one exists.  The
+     * complete and further triggers {@link #tryComplete} on this
-     * given rawResult is used as an argument to {@link #setRawResult}
+     * task's completer, if one exists.  The given rawResult is
-     * before invoking {@link #onCompletion} or marking this task as
+     * used as an argument to {@link #setRawResult} before invoking
-     * complete; its value is meaningful only for classes overriding
+     * {@link #onCompletion(CountedCompleter)} or marking this task
-     * {@code setRawResult}.
+     * as complete; its value is meaningful only for classes
+     * overriding {@code setRawResult}.  This method does not modify
+     * the pending count.
      *
      * <p>This method may be useful when forcing completion as soon as
      * any one (versus all) of several subtask results are obtained.
@@ -632,7 +636,6 @@ public abstract class CountedCompleter<T> extends ForkJoinTask<T> {
             p.tryComplete();
     }
 
-
     /**
      * If this task's pending count is zero, returns this task;
      * otherwise decrements its pending count and returns {@code
@@ -653,8 +656,8 @@ public abstract class CountedCompleter<T> extends ForkJoinTask<T> {
     /**
      * If this task does not have a completer, invokes {@link
      * ForkJoinTask#quietlyComplete} and returns {@code null}.  Or, if
-     * this task's pending count is non-zero, decrements its pending
+     * the completer's pending count is non-zero, decrements that
-     * count and returns {@code null}.  Otherwise, returns the
+     * pending count and returns {@code null}.  Otherwise, returns the
      * completer.  This method can be used as part of a completion
      * traversal loop for homogeneous task hierarchies:
      *
@@ -690,14 +693,35 @@ public abstract class CountedCompleter<T> extends ForkJoinTask<T> {
         }
     }
 
+    /**
+     * If this task has not completed, attempts to process at most the
+     * given number of other unprocessed tasks for which this task is
+     * on the completion path, if any are known to exist.
+     *
+     * @param maxTasks the maximum number of tasks to process.  If
+     *                 less than or equal to zero, then no tasks are
+     *                 processed.
+     */
+    public final void helpComplete(int maxTasks) {
+        Thread t; ForkJoinWorkerThread wt;
+        if (maxTasks > 0 && status >= 0) {
+            if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread)
+                (wt = (ForkJoinWorkerThread)t).pool.
+                    helpComplete(wt.workQueue, this, maxTasks);
+            else
+                ForkJoinPool.common.externalHelpComplete(this, maxTasks);
+        }
+    }
+
     /**
      * Supports ForkJoinTask exception propagation.
      */
     void internalPropagateException(Throwable ex) {
         CountedCompleter<?> a = this, s = a;
         while (a.onExceptionalCompletion(ex, s) &&
-               (a = (s = a).completer) != null && a.status >= 0)
+               (a = (s = a).completer) != null && a.status >= 0 &&
-            a.recordExceptionalCompletion(ex);
+               a.recordExceptionalCompletion(ex) == EXCEPTIONAL)
+            ;
     }
 
     /**

jdk/src/share/classes/java/util/concurrent/ExecutionException.java

@@ -48,14 +48,14 @@ public class ExecutionException extends Exception {
     private static final long serialVersionUID = 7830266012832686185L;
 
     /**
-     * Constructs an <tt>ExecutionException</tt> with no detail message.
+     * Constructs an {@code ExecutionException} with no detail message.
      * The cause is not initialized, and may subsequently be
      * initialized by a call to {@link #initCause(Throwable) initCause}.
      */
     protected ExecutionException() { }
 
     /**
-     * Constructs an <tt>ExecutionException</tt> with the specified detail
+     * Constructs an {@code ExecutionException} with the specified detail
      * message. The cause is not initialized, and may subsequently be
      * initialized by a call to {@link #initCause(Throwable) initCause}.
      *
@@ -66,7 +66,7 @@ public class ExecutionException extends Exception {
     }
 
     /**
-     * Constructs an <tt>ExecutionException</tt> with the specified detail
+     * Constructs an {@code ExecutionException} with the specified detail
      * message and cause.
      *
      * @param  message the detail message
@@ -78,7 +78,7 @@ public class ExecutionException extends Exception {
     }
 
     /**
-     * Constructs an <tt>ExecutionException</tt> with the specified cause.
+     * Constructs an {@code ExecutionException} with the specified cause.
      * The detail message is set to {@code (cause == null ? null :
      * cause.toString())} (which typically contains the class and
      * detail message of {@code cause}).

jdk/src/share/classes/java/util/concurrent/Executor.java

@@ -39,9 +39,9 @@ package java.util.concurrent;
  * An object that executes submitted {@link Runnable} tasks. This
  * interface provides a way of decoupling task submission from the
  * mechanics of how each task will be run, including details of thread
- * use, scheduling, etc.  An <tt>Executor</tt> is normally used
+ * use, scheduling, etc.  An {@code Executor} is normally used
  * instead of explicitly creating threads. For example, rather than
- * invoking <tt>new Thread(new(RunnableTask())).start()</tt> for each
+ * invoking {@code new Thread(new(RunnableTask())).start()} for each
  * of a set of tasks, you might use:
  *
  * <pre>
@@ -51,7 +51,7 @@ package java.util.concurrent;
  * ...
  * </pre>
  *
- * However, the <tt>Executor</tt> interface does not strictly
+ * However, the {@code Executor} interface does not strictly
  * require that execution be asynchronous. In the simplest case, an
  * executor can run the submitted task immediately in the caller's
  * thread:
@@ -74,7 +74,7 @@ package java.util.concurrent;
  *   }
  * }}</pre>
  *
- * Many <tt>Executor</tt> implementations impose some sort of
+ * Many {@code Executor} implementations impose some sort of
  * limitation on how and when tasks are scheduled.  The executor below
  * serializes the submission of tasks to a second executor,
  * illustrating a composite executor.
@@ -111,7 +111,7 @@ package java.util.concurrent;
  *   }
  * }}</pre>
  *
- * The <tt>Executor</tt> implementations provided in this package
+ * The {@code Executor} implementations provided in this package
  * implement {@link ExecutorService}, which is a more extensive
  * interface.  The {@link ThreadPoolExecutor} class provides an
  * extensible thread pool implementation. The {@link Executors} class
@@ -130,11 +130,11 @@ public interface Executor {
     /**
      * Executes the given command at some time in the future.  The command
      * may execute in a new thread, in a pooled thread, or in the calling
-     * thread, at the discretion of the <tt>Executor</tt> implementation.
+     * thread, at the discretion of the {@code Executor} implementation.
      *
      * @param command the runnable task
      * @throws RejectedExecutionException if this task cannot be
-     * accepted for execution.
+     * accepted for execution
      * @throws NullPointerException if command is null
      */
     void execute(Runnable command);

jdk/src/share/classes/java/util/concurrent/ExecutorService.java

@@ -42,21 +42,21 @@ import java.util.Collection;
  * methods that can produce a {@link Future} for tracking progress of
  * one or more asynchronous tasks.
  *
- * <p> An <tt>ExecutorService</tt> can be shut down, which will cause
+ * <p>An {@code ExecutorService} can be shut down, which will cause
  * it to reject new tasks.  Two different methods are provided for
- * shutting down an <tt>ExecutorService</tt>. The {@link #shutdown}
+ * shutting down an {@code ExecutorService}. The {@link #shutdown}
  * method will allow previously submitted tasks to execute before
  * terminating, while the {@link #shutdownNow} method prevents waiting
  * tasks from starting and attempts to stop currently executing tasks.
  * Upon termination, an executor has no tasks actively executing, no
  * tasks awaiting execution, and no new tasks can be submitted.  An
- * unused <tt>ExecutorService</tt> should be shut down to allow
+ * unused {@code ExecutorService} should be shut down to allow
  * reclamation of its resources.
  *
- * <p> Method <tt>submit</tt> extends base method {@link
+ * <p>Method {@code submit} extends base method {@link
- * Executor#execute} by creating and returning a {@link Future} that
+ * Executor#execute(Runnable)} by creating and returning a {@link Future}
- * can be used to cancel execution and/or wait for completion.
+ * that can be used to cancel execution and/or wait for completion.
- * Methods <tt>invokeAny</tt> and <tt>invokeAll</tt> perform the most
+ * Methods {@code invokeAny} and {@code invokeAll} perform the most
  * commonly useful forms of bulk execution, executing a collection of
  * tasks and then waiting for at least one, or all, to
  * complete. (Class {@link ExecutorCompletionService} can be used to
@@ -101,9 +101,9 @@ import java.util.Collection;
  *   }
  * }}</pre>
  *
- * The following method shuts down an <tt>ExecutorService</tt> in two phases,
+ * The following method shuts down an {@code ExecutorService} in two phases,
- * first by calling <tt>shutdown</tt> to reject incoming tasks, and then
+ * first by calling {@code shutdown} to reject incoming tasks, and then
- * calling <tt>shutdownNow</tt>, if necessary, to cancel any lingering tasks:
+ * calling {@code shutdownNow}, if necessary, to cancel any lingering tasks:
  *
  *  <pre> {@code
  * void shutdownAndAwaitTermination(ExecutorService pool) {
@@ -149,8 +149,8 @@ public interface ExecutorService extends Executor {
      *         shutting down this ExecutorService may manipulate
      *         threads that the caller is not permitted to modify
      *         because it does not hold {@link
-     *         java.lang.RuntimePermission}<tt>("modifyThread")</tt>,
+     *         java.lang.RuntimePermission}{@code ("modifyThread")},
-     *         or the security manager's <tt>checkAccess</tt> method
+     *         or the security manager's {@code checkAccess} method
      *         denies access.
      */
     void shutdown();
@@ -174,25 +174,25 @@ public interface ExecutorService extends Executor {
      *         shutting down this ExecutorService may manipulate
      *         threads that the caller is not permitted to modify
      *         because it does not hold {@link
-     *         java.lang.RuntimePermission}<tt>("modifyThread")</tt>,
+     *         java.lang.RuntimePermission}{@code ("modifyThread")},
-     *         or the security manager's <tt>checkAccess</tt> method
+     *         or the security manager's {@code checkAccess} method
      *         denies access.
      */
     List<Runnable> shutdownNow();
 
     /**
-     * Returns <tt>true</tt> if this executor has been shut down.
+     * Returns {@code true} if this executor has been shut down.
      *
-     * @return <tt>true</tt> if this executor has been shut down
+     * @return {@code true} if this executor has been shut down
      */
     boolean isShutdown();
 
     /**
-     * Returns <tt>true</tt> if all tasks have completed following shut down.
+     * Returns {@code true} if all tasks have completed following shut down.
-     * Note that <tt>isTerminated</tt> is never <tt>true</tt> unless
+     * Note that {@code isTerminated} is never {@code true} unless
-     * either <tt>shutdown</tt> or <tt>shutdownNow</tt> was called first.
+     * either {@code shutdown} or {@code shutdownNow} was called first.
      *
-     * @return <tt>true</tt> if all tasks have completed following shut down
+     * @return {@code true} if all tasks have completed following shut down
      */
     boolean isTerminated();
 
@@ -203,8 +203,8 @@ public interface ExecutorService extends Executor {
      *
      * @param timeout the maximum time to wait
      * @param unit the time unit of the timeout argument
-     * @return <tt>true</tt> if this executor terminated and
+     * @return {@code true} if this executor terminated and
-     *         <tt>false</tt> if the timeout elapsed before termination
+     *         {@code false} if the timeout elapsed before termination
      * @throws InterruptedException if interrupted while waiting
      */
     boolean awaitTermination(long timeout, TimeUnit unit)
@@ -213,15 +213,15 @@ public interface ExecutorService extends Executor {
     /**
      * Submits a value-returning task for execution and returns a
      * Future representing the pending results of the task. The
-     * Future's <tt>get</tt> method will return the task's result upon
+     * Future's {@code get} method will return the task's result upon
      * successful completion.
      *
      * <p>
      * If you would like to immediately block waiting
      * for a task, you can use constructions of the form
-     * <tt>result = exec.submit(aCallable).get();</tt>
+     * {@code result = exec.submit(aCallable).get();}
      *
-     * <p> Note: The {@link Executors} class includes a set of methods
+     * <p>Note: The {@link Executors} class includes a set of methods
      * that can convert some other common closure-like objects,
      * for example, {@link java.security.PrivilegedAction} to
      * {@link Callable} form so they can be submitted.
@@ -236,7 +236,7 @@ public interface ExecutorService extends Executor {
 
     /**
      * Submits a Runnable task for execution and returns a Future
-     * representing that task. The Future's <tt>get</tt> method will
+     * representing that task. The Future's {@code get} method will
      * return the given result upon successful completion.
      *
      * @param task the task to submit
@@ -250,8 +250,8 @@ public interface ExecutorService extends Executor {
 
     /**
      * Submits a Runnable task for execution and returns a Future
-     * representing that task. The Future's <tt>get</tt> method will
+     * representing that task. The Future's {@code get} method will
-     * return <tt>null</tt> upon <em>successful</em> completion.
+     * return {@code null} upon <em>successful</em> completion.
      *
      * @param task the task to submit
      * @return a Future representing pending completion of the task
@@ -264,7 +264,7 @@ public interface ExecutorService extends Executor {
     /**
      * Executes the given tasks, returning a list of Futures holding
      * their status and results when all complete.
-     * {@link Future#isDone} is <tt>true</tt> for each
+     * {@link Future#isDone} is {@code true} for each
      * element of the returned list.
      * Note that a <em>completed</em> task could have
      * terminated either normally or by throwing an exception.
@@ -272,12 +272,12 @@ public interface ExecutorService extends Executor {
      * collection is modified while this operation is in progress.
      *
      * @param tasks the collection of tasks
-     * @return A list of Futures representing the tasks, in the same
+     * @return a list of Futures representing the tasks, in the same
      *         sequential order as produced by the iterator for the
-     *         given task list, each of which has completed.
+     *         given task list, each of which has completed
      * @throws InterruptedException if interrupted while waiting, in
-     *         which case unfinished tasks are cancelled.
+     *         which case unfinished tasks are cancelled
-     * @throws NullPointerException if tasks or any of its elements are <tt>null</tt>
+     * @throws NullPointerException if tasks or any of its elements are {@code null}
      * @throws RejectedExecutionException if any task cannot be
      *         scheduled for execution
      */
@@ -288,7 +288,7 @@ public interface ExecutorService extends Executor {
      * Executes the given tasks, returning a list of Futures holding
      * their status and results
      * when all complete or the timeout expires, whichever happens first.
-     * {@link Future#isDone} is <tt>true</tt> for each
+     * {@link Future#isDone} is {@code true} for each
      * element of the returned list.
      * Upon return, tasks that have not completed are cancelled.
      * Note that a <em>completed</em> task could have
@@ -307,7 +307,7 @@ public interface ExecutorService extends Executor {
      * @throws InterruptedException if interrupted while waiting, in
      *         which case unfinished tasks are cancelled
      * @throws NullPointerException if tasks, any of its elements, or
-     *         unit are <tt>null</tt>
+     *         unit are {@code null}
      * @throws RejectedExecutionException if any task cannot be scheduled
      *         for execution
      */
@@ -327,7 +327,7 @@ public interface ExecutorService extends Executor {
      * @return the result returned by one of the tasks
      * @throws InterruptedException if interrupted while waiting
      * @throws NullPointerException if tasks or any element task
-     *         subject to execution is <tt>null</tt>
+     *         subject to execution is {@code null}
      * @throws IllegalArgumentException if tasks is empty
      * @throws ExecutionException if no task successfully completes
      * @throws RejectedExecutionException if tasks cannot be scheduled
@@ -348,10 +348,10 @@ public interface ExecutorService extends Executor {
      * @param tasks the collection of tasks
      * @param timeout the maximum time to wait
      * @param unit the time unit of the timeout argument
-     * @return the result returned by one of the tasks.
+     * @return the result returned by one of the tasks
      * @throws InterruptedException if interrupted while waiting
      * @throws NullPointerException if tasks, or unit, or any element
-     *         task subject to execution is <tt>null</tt>
+     *         task subject to execution is {@code null}
      * @throws TimeoutException if the given timeout elapses before
      *         any task successfully completes
      * @throws ExecutionException if no task successfully completes

jdk/src/share/classes/java/util/concurrent/Executors.java

@@ -62,7 +62,7 @@ import sun.security.util.SecurityConstants;
  *        that sets newly created threads to a known state.
  *   <li> Methods that create and return a {@link Callable}
  *        out of other closure-like forms, so they can be used
- *        in execution methods requiring <tt>Callable</tt>.
+ *        in execution methods requiring {@code Callable}.
  * </ul>
  *
  * @since 1.5
@@ -73,7 +73,7 @@ public class Executors {
     /**
      * Creates a thread pool that reuses a fixed number of threads
      * operating off a shared unbounded queue.  At any point, at most
-     * <tt>nThreads</tt> threads will be active processing tasks.
+     * {@code nThreads} threads will be active processing tasks.
      * If additional tasks are submitted when all threads are active,
      * they will wait in the queue until a thread is available.
      * If any thread terminates due to a failure during execution
@@ -91,11 +91,48 @@ public class Executors {
                                       new LinkedBlockingQueue<Runnable>());
     }
 
+    /**
+     * Creates a thread pool that maintains enough threads to support
+     * the given parallelism level, and may use multiple queues to
+     * reduce contention. The parallelism level corresponds to the
+     * maximum number of threads actively engaged in, or available to
+     * engage in, task processing. The actual number of threads may
+     * grow and shrink dynamically. A work-stealing pool makes no
+     * guarantees about the order in which submitted tasks are
+     * executed.
+     *
+     * @param parallelism the targeted parallelism level
+     * @return the newly created thread pool
+     * @throws IllegalArgumentException if {@code parallelism <= 0}
+     * @since 1.8
+     */
+    public static ExecutorService newWorkStealingPool(int parallelism) {
+        return new ForkJoinPool
+            (parallelism,
+             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
+             null, true);
+    }
+
+    /**
+     * Creates a work-stealing thread pool using all
+     * {@link Runtime#availableProcessors available processors}
+     * as its target parallelism level.
+     * @return the newly created thread pool
+     * @see #newWorkStealingPool(int)
+     * @since 1.8
+     */
+    public static ExecutorService newWorkStealingPool() {
+        return new ForkJoinPool
+            (Runtime.getRuntime().availableProcessors(),
+             ForkJoinPool.defaultForkJoinWorkerThreadFactory,
+             null, true);
+    }
+
     /**
      * Creates a thread pool that reuses a fixed number of threads
      * operating off a shared unbounded queue, using the provided
      * ThreadFactory to create new threads when needed.  At any point,
-     * at most <tt>nThreads</tt> threads will be active processing
+     * at most {@code nThreads} threads will be active processing
      * tasks.  If additional tasks are submitted when all threads are
      * active, they will wait in the queue until a thread is
      * available.  If any thread terminates due to a failure during
@@ -125,7 +162,7 @@ public class Executors {
      * subsequent tasks.)  Tasks are guaranteed to execute
      * sequentially, and no more than one task will be active at any
      * given time. Unlike the otherwise equivalent
-     * <tt>newFixedThreadPool(1)</tt> the returned executor is
+     * {@code newFixedThreadPool(1)} the returned executor is
      * guaranteed not to be reconfigurable to use additional threads.
      *
      * @return the newly created single-threaded Executor
@@ -141,7 +178,7 @@ public class Executors {
      * Creates an Executor that uses a single worker thread operating
      * off an unbounded queue, and uses the provided ThreadFactory to
      * create a new thread when needed. Unlike the otherwise
-     * equivalent <tt>newFixedThreadPool(1, threadFactory)</tt> the
+     * equivalent {@code newFixedThreadPool(1, threadFactory)} the
      * returned executor is guaranteed not to be reconfigurable to use
      * additional threads.
      *
@@ -164,7 +201,7 @@ public class Executors {
      * will reuse previously constructed threads when they are
      * available.  These pools will typically improve the performance
      * of programs that execute many short-lived asynchronous tasks.
-     * Calls to <tt>execute</tt> will reuse previously constructed
+     * Calls to {@code execute} will reuse previously constructed
      * threads if available. If no existing thread is available, a new
      * thread will be created and added to the pool. Threads that have
      * not been used for sixty seconds are terminated and removed from
@@ -206,7 +243,7 @@ public class Executors {
      * subsequent tasks.)  Tasks are guaranteed to execute
      * sequentially, and no more than one task will be active at any
      * given time. Unlike the otherwise equivalent
-     * <tt>newScheduledThreadPool(1)</tt> the returned executor is
+     * {@code newScheduledThreadPool(1)} the returned executor is
      * guaranteed not to be reconfigurable to use additional threads.
      * @return the newly created scheduled executor
      */
@@ -223,7 +260,7 @@ public class Executors {
      * place if needed to execute subsequent tasks.)  Tasks are
      * guaranteed to execute sequentially, and no more than one task
      * will be active at any given time. Unlike the otherwise
-     * equivalent <tt>newScheduledThreadPool(1, threadFactory)</tt>
+     * equivalent {@code newScheduledThreadPool(1, threadFactory)}
      * the returned executor is guaranteed not to be reconfigurable to
      * use additional threads.
      * @param threadFactory the factory to use when creating new
@@ -240,7 +277,7 @@ public class Executors {
      * Creates a thread pool that can schedule commands to run after a
      * given delay, or to execute periodically.
      * @param corePoolSize the number of threads to keep in the pool,
-     * even if they are idle.
+     * even if they are idle
      * @return a newly created scheduled thread pool
      * @throws IllegalArgumentException if {@code corePoolSize < 0}
      */
@@ -252,9 +289,9 @@ public class Executors {
      * Creates a thread pool that can schedule commands to run after a
      * given delay, or to execute periodically.
      * @param corePoolSize the number of threads to keep in the pool,
-     * even if they are idle.
+     * even if they are idle
      * @param threadFactory the factory to use when the executor
-     * creates a new thread.
+     * creates a new thread
      * @return a newly created scheduled thread pool
      * @throws IllegalArgumentException if {@code corePoolSize < 0}
      * @throws NullPointerException if threadFactory is null
@@ -264,7 +301,6 @@ public class Executors {
         return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
     }
 
-
     /**
      * Returns an object that delegates all defined {@link
      * ExecutorService} methods to the given executor, but not any
@@ -272,7 +308,7 @@ public class Executors {
      * casts. This provides a way to safely "freeze" configuration and
      * disallow tuning of a given concrete implementation.
      * @param executor the underlying implementation
-     * @return an <tt>ExecutorService</tt> instance
+     * @return an {@code ExecutorService} instance
      * @throws NullPointerException if executor null
      */
     public static ExecutorService unconfigurableExecutorService(ExecutorService executor) {
@@ -288,7 +324,7 @@ public class Executors {
      * casts. This provides a way to safely "freeze" configuration and
      * disallow tuning of a given concrete implementation.
      * @param executor the underlying implementation
-     * @return a <tt>ScheduledExecutorService</tt> instance
+     * @return a {@code ScheduledExecutorService} instance
      * @throws NullPointerException if executor null
      */
     public static ScheduledExecutorService unconfigurableScheduledExecutorService(ScheduledExecutorService executor) {
@@ -303,9 +339,9 @@ public class Executors {
      * same {@link ThreadGroup}. If there is a {@link
      * java.lang.SecurityManager}, it uses the group of {@link
      * System#getSecurityManager}, else the group of the thread
-     * invoking this <tt>defaultThreadFactory</tt> method. Each new
+     * invoking this {@code defaultThreadFactory} method. Each new
      * thread is created as a non-daemon thread with priority set to
-     * the smaller of <tt>Thread.NORM_PRIORITY</tt> and the maximum
+     * the smaller of {@code Thread.NORM_PRIORITY} and the maximum
      * priority permitted in the thread group.  New threads have names
      * accessible via {@link Thread#getName} of
      * <em>pool-N-thread-M</em>, where <em>N</em> is the sequence
@@ -324,30 +360,31 @@ public class Executors {
      * Executors#defaultThreadFactory}, additionally setting the
      * AccessControlContext and contextClassLoader of new threads to
      * be the same as the thread invoking this
-     * <tt>privilegedThreadFactory</tt> method.  A new
+     * {@code privilegedThreadFactory} method.  A new
-     * <tt>privilegedThreadFactory</tt> can be created within an
+     * {@code privilegedThreadFactory} can be created within an
-     * {@link AccessController#doPrivileged} action setting the
+     * {@link AccessController#doPrivileged AccessController.doPrivileged}
-     * current thread's access control context to create threads with
+     * action setting the current thread's access control context to
-     * the selected permission settings holding within that action.
+     * create threads with the selected permission settings holding
+     * within that action.
      *
-     * <p> Note that while tasks running within such threads will have
+     * <p>Note that while tasks running within such threads will have
      * the same access control and class loader settings as the
      * current thread, they need not have the same {@link
      * java.lang.ThreadLocal} or {@link
      * java.lang.InheritableThreadLocal} values. If necessary,
      * particular values of thread locals can be set or reset before
      * any task runs in {@link ThreadPoolExecutor} subclasses using
-     * {@link ThreadPoolExecutor#beforeExecute}. Also, if it is
+     * {@link ThreadPoolExecutor#beforeExecute(Thread, Runnable)}.
-     * necessary to initialize worker threads to have the same
+     * Also, if it is necessary to initialize worker threads to have
-     * InheritableThreadLocal settings as some other designated
+     * the same InheritableThreadLocal settings as some other
-     * thread, you can create a custom ThreadFactory in which that
+     * designated thread, you can create a custom ThreadFactory in
-     * thread waits for and services requests to create others that
+     * which that thread waits for and services requests to create
-     * will inherit its values.
+     * others that will inherit its values.
      *
      * @return a thread factory
      * @throws AccessControlException if the current access control
      * context does not have permission to both get and set context
-     * class loader.
+     * class loader
      */
     public static ThreadFactory privilegedThreadFactory() {
         return new PrivilegedThreadFactory();
@@ -357,7 +394,7 @@ public class Executors {
      * Returns a {@link Callable} object that, when
      * called, runs the given task and returns the given result.  This
      * can be useful when applying methods requiring a
-     * <tt>Callable</tt> to an otherwise resultless action.
+     * {@code Callable} to an otherwise resultless action.
      * @param task the task to run
      * @param result the result to return
      * @return a callable object
@@ -371,7 +408,7 @@ public class Executors {
 
     /**
      * Returns a {@link Callable} object that, when
-     * called, runs the given task and returns <tt>null</tt>.
+     * called, runs the given task and returns {@code null}.
      * @param task the task to run
      * @return a callable object
      * @throws NullPointerException if task null
@@ -412,18 +449,17 @@ public class Executors {
     }
 
     /**
-     * Returns a {@link Callable} object that will, when
+     * Returns a {@link Callable} object that will, when called,
-     * called, execute the given <tt>callable</tt> under the current
+     * execute the given {@code callable} under the current access
-     * access control context. This method should normally be
+     * control context. This method should normally be invoked within
-     * invoked within an {@link AccessController#doPrivileged} action
+     * an {@link AccessController#doPrivileged AccessController.doPrivileged}
-     * to create callables that will, if possible, execute under the
+     * action to create callables that will, if possible, execute
-     * selected permission settings holding within that action; or if
+     * under the selected permission settings holding within that
-     * not possible, throw an associated {@link
+     * action; or if not possible, throw an associated {@link
      * AccessControlException}.
      * @param callable the underlying task
      * @return a callable object
      * @throws NullPointerException if callable null
-     *
      */
     public static <T> Callable<T> privilegedCallable(Callable<T> callable) {
         if (callable == null)
@@ -432,22 +468,23 @@ public class Executors {
     }
 
     /**
-     * Returns a {@link Callable} object that will, when
+     * Returns a {@link Callable} object that will, when called,
-     * called, execute the given <tt>callable</tt> under the current
+     * execute the given {@code callable} under the current access
-     * access control context, with the current context class loader
+     * control context, with the current context class loader as the
-     * as the context class loader. This method should normally be
+     * context class loader. This method should normally be invoked
-     * invoked within an {@link AccessController#doPrivileged} action
+     * within an
-     * to create callables that will, if possible, execute under the
+     * {@link AccessController#doPrivileged AccessController.doPrivileged}
-     * selected permission settings holding within that action; or if
+     * action to create callables that will, if possible, execute
-     * not possible, throw an associated {@link
+     * under the selected permission settings holding within that
+     * action; or if not possible, throw an associated {@link
      * AccessControlException}.
-     * @param callable the underlying task
      *
+     * @param callable the underlying task
      * @return a callable object
      * @throws NullPointerException if callable null
      * @throws AccessControlException if the current access control
      * context does not have permission to both set and get context
-     * class loader.
+     * class loader
      */
     public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable) {
         if (callable == null)
@@ -699,7 +736,6 @@ public class Executors {
         }
     }
 
-
     /** Cannot instantiate. */
     private Executors() {}
 }

jdk/src/share/classes/java/util/concurrent/ForkJoinTask.java

@@ -165,7 +165,7 @@ import java.lang.reflect.Constructor;
  * supports other methods and techniques (for example the use of
  * {@link Phaser}, {@link #helpQuiesce}, and {@link #complete}) that
  * may be of use in constructing custom subclasses for problems that
- * are not statically structured as DAGs. To support such usages a
+ * are not statically structured as DAGs. To support such usages, a
  * ForkJoinTask may be atomically <em>tagged</em> with a {@code short}
  * value using {@link #setForkJoinTaskTag} or {@link
  * #compareAndSetForkJoinTaskTag} and checked using {@link
@@ -314,25 +314,35 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
      */
     private int externalAwaitDone() {
         int s;
-        ForkJoinPool.externalHelpJoin(this);
+        ForkJoinPool cp = ForkJoinPool.common;
-        boolean interrupted = false;
+        if ((s = status) >= 0) {
-        while ((s = status) >= 0) {
+            if (cp != null) {
-            if (U.compareAndSwapInt(this, STATUS, s, s | SIGNAL)) {
+                if (this instanceof CountedCompleter)
-                synchronized (this) {
+                    s = cp.externalHelpComplete((CountedCompleter<?>)this, Integer.MAX_VALUE);
-                    if (status >= 0) {
+                else if (cp.tryExternalUnpush(this))
-                        try {
+                    s = doExec();
-                            wait();
+            }
-                        } catch (InterruptedException ie) {
+            if (s >= 0 && (s = status) >= 0) {
-                            interrupted = true;
+                boolean interrupted = false;
+                do {
+                    if (U.compareAndSwapInt(this, STATUS, s, s | SIGNAL)) {
+                        synchronized (this) {
+                            if (status >= 0) {
+                                try {
+                                    wait();
+                                } catch (InterruptedException ie) {
+                                    interrupted = true;
+                                }
+                            }
+                            else
+                                notifyAll();
                         }
                     }
-                    else
+                } while ((s = status) >= 0);
-                        notifyAll();
+                if (interrupted)
-                }
+                    Thread.currentThread().interrupt();
             }
         }
-        if (interrupted)
-            Thread.currentThread().interrupt();
         return s;
     }
 
@@ -341,9 +351,15 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
      */
     private int externalInterruptibleAwaitDone() throws InterruptedException {
         int s;
+        ForkJoinPool cp = ForkJoinPool.common;
         if (Thread.interrupted())
             throw new InterruptedException();
-        ForkJoinPool.externalHelpJoin(this);
+        if ((s = status) >= 0 && cp != null) {
+            if (this instanceof CountedCompleter)
+                cp.externalHelpComplete((CountedCompleter<?>)this, Integer.MAX_VALUE);
+            else if (cp.tryExternalUnpush(this))
+                doExec();
+        }
         while ((s = status) >= 0) {
             if (U.compareAndSwapInt(this, STATUS, s, s | SIGNAL)) {
                 synchronized (this) {
@@ -357,7 +373,6 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
         return s;
     }
 
-
     /**
      * Implementation for join, get, quietlyJoin. Directly handles
      * only cases of already-completed, external wait, and
@@ -629,14 +644,9 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
     /**
      * A version of "sneaky throw" to relay exceptions
      */
-    static void rethrow(final Throwable ex) {
+    static void rethrow(Throwable ex) {
-        if (ex != null) {
+        if (ex != null)
-            if (ex instanceof Error)
-                throw (Error)ex;
-            if (ex instanceof RuntimeException)
-                throw (RuntimeException)ex;
             ForkJoinTask.<RuntimeException>uncheckedThrow(ex);
-        }
     }
 
     /**
@@ -646,8 +656,7 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
      */
     @SuppressWarnings("unchecked") static <T extends Throwable>
         void uncheckedThrow(Throwable t) throws T {
-        if (t != null)
+        throw (T)t; // rely on vacuous cast
-            throw (T)t; // rely on vacuous cast
     }
 
     /**
@@ -1010,6 +1019,7 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
         // Messy in part because we measure in nanosecs, but wait in millisecs
         int s; long ms;
         long ns = unit.toNanos(timeout);
+        ForkJoinPool cp;
         if ((s = status) >= 0 && ns > 0L) {
             long deadline = System.nanoTime() + ns;
             ForkJoinPool p = null;
@@ -1021,8 +1031,12 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
                 w = wt.workQueue;
                 p.helpJoinOnce(w, this); // no retries on failure
             }
-            else
+            else if ((cp = ForkJoinPool.common) != null) {
-                ForkJoinPool.externalHelpJoin(this);
+                if (this instanceof CountedCompleter)
+                    cp.externalHelpComplete((CountedCompleter<?>)this, Integer.MAX_VALUE);
+                else if (cp.tryExternalUnpush(this))
+                    doExec();
+            }
             boolean canBlock = false;
             boolean interrupted = false;
             try {
@@ -1030,7 +1044,7 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
                     if (w != null && w.qlock < 0)
                         cancelIgnoringExceptions(this);
                     else if (!canBlock) {
-                        if (p == null || p.tryCompensate())
+                        if (p == null || p.tryCompensate(p.ctl))
                             canBlock = true;
                     }
                     else {
@@ -1171,7 +1185,7 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
         Thread t;
         return (((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) ?
                 ((ForkJoinWorkerThread)t).workQueue.tryUnpush(this) :
-                ForkJoinPool.tryExternalUnpush(this));
+                ForkJoinPool.common.tryExternalUnpush(this));
     }
 
     /**
@@ -1340,7 +1354,7 @@ public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
      *
      * @param e the expected tag value
      * @param tag the new tag value
-     * @return true if successful; i.e., the current value was
+     * @return {@code true} if successful; i.e., the current value was
      * equal to e and is now tag.
      * @since 1.8
      */

jdk/src/share/classes/java/util/concurrent/ForkJoinWorkerThread.java

@@ -43,8 +43,8 @@ package java.util.concurrent;
  * scheduling or execution.  However, you can override initialization
  * and termination methods surrounding the main task processing loop.
  * If you do create such a subclass, you will also need to supply a
- * custom {@link ForkJoinPool.ForkJoinWorkerThreadFactory} to use it
+ * custom {@link ForkJoinPool.ForkJoinWorkerThreadFactory} to
- * in a {@code ForkJoinPool}.
+ * {@linkplain ForkJoinPool#ForkJoinPool use it} in a {@code ForkJoinPool}.
  *
  * @since 1.7
  * @author Doug Lea
@@ -89,16 +89,17 @@ public class ForkJoinWorkerThread extends Thread {
     }
 
     /**
-     * Returns the index number of this thread in its pool.  The
+     * Returns the unique index number of this thread in its pool.
-     * returned value ranges from zero to the maximum number of
+     * The returned value ranges from zero to the maximum number of
-     * threads (minus one) that have ever been created in the pool.
+     * threads (minus one) that may exist in the pool, and does not
-     * This method may be useful for applications that track status or
+     * change during the lifetime of the thread.  This method may be
-     * collect results per-worker rather than per-task.
+     * useful for applications that track status or collect results
+     * per-worker-thread rather than per-task.
      *
      * @return the index number
      */
     public int getPoolIndex() {
-        return workQueue.poolIndex;
+        return workQueue.poolIndex >>> 1; // ignore odd/even tag bit
     }
 
     /**

jdk/src/share/classes/java/util/concurrent/Future.java

@@ -36,19 +36,19 @@
 package java.util.concurrent;
 
 /**
- * A <tt>Future</tt> represents the result of an asynchronous
+ * A {@code Future} represents the result of an asynchronous
  * computation.  Methods are provided to check if the computation is
  * complete, to wait for its completion, and to retrieve the result of
  * the computation.  The result can only be retrieved using method
- * <tt>get</tt> when the computation has completed, blocking if
+ * {@code get} when the computation has completed, blocking if
  * necessary until it is ready.  Cancellation is performed by the
- * <tt>cancel</tt> method.  Additional methods are provided to
+ * {@code cancel} method.  Additional methods are provided to
  * determine if the task completed normally or was cancelled. Once a
  * computation has completed, the computation cannot be cancelled.
- * If you would like to use a <tt>Future</tt> for the sake
+ * If you would like to use a {@code Future} for the sake
  * of cancellability but not provide a usable result, you can
  * declare types of the form {@code Future<?>} and
- * return <tt>null</tt> as a result of the underlying task.
+ * return {@code null} as a result of the underlying task.
  *
  * <p>
  * <b>Sample Usage</b> (Note that the following classes are all
@@ -72,9 +72,9 @@ package java.util.concurrent;
  *   }
  * }}</pre>
  *
- * The {@link FutureTask} class is an implementation of <tt>Future</tt> that
+ * The {@link FutureTask} class is an implementation of {@code Future} that
- * implements <tt>Runnable</tt>, and so may be executed by an <tt>Executor</tt>.
+ * implements {@code Runnable}, and so may be executed by an {@code Executor}.
- * For example, the above construction with <tt>submit</tt> could be replaced by:
+ * For example, the above construction with {@code submit} could be replaced by:
  *  <pre> {@code
  * FutureTask<String> future =
  *   new FutureTask<String>(new Callable<String>() {
@@ -91,7 +91,7 @@ package java.util.concurrent;
  * @see Executor
  * @since 1.5
  * @author Doug Lea
- * @param <V> The result type returned by this Future's <tt>get</tt> method
+ * @param <V> The result type returned by this Future's {@code get} method
  */
 public interface Future<V> {
 
@@ -99,41 +99,41 @@ public interface Future<V> {
      * Attempts to cancel execution of this task.  This attempt will
      * fail if the task has already completed, has already been cancelled,
      * or could not be cancelled for some other reason. If successful,
-     * and this task has not started when <tt>cancel</tt> is called,
+     * and this task has not started when {@code cancel} is called,
      * this task should never run.  If the task has already started,
-     * then the <tt>mayInterruptIfRunning</tt> parameter determines
+     * then the {@code mayInterruptIfRunning} parameter determines
      * whether the thread executing this task should be interrupted in
      * an attempt to stop the task.
      *
      * <p>After this method returns, subsequent calls to {@link #isDone} will
-     * always return <tt>true</tt>.  Subsequent calls to {@link #isCancelled}
+     * always return {@code true}.  Subsequent calls to {@link #isCancelled}
-     * will always return <tt>true</tt> if this method returned <tt>true</tt>.
+     * will always return {@code true} if this method returned {@code true}.
      *
-     * @param mayInterruptIfRunning <tt>true</tt> if the thread executing this
+     * @param mayInterruptIfRunning {@code true} if the thread executing this
      * task should be interrupted; otherwise, in-progress tasks are allowed
      * to complete
-     * @return <tt>false</tt> if the task could not be cancelled,
+     * @return {@code false} if the task could not be cancelled,
      * typically because it has already completed normally;
-     * <tt>true</tt> otherwise
+     * {@code true} otherwise
      */
     boolean cancel(boolean mayInterruptIfRunning);
 
     /**
-     * Returns <tt>true</tt> if this task was cancelled before it completed
+     * Returns {@code true} if this task was cancelled before it completed
      * normally.
      *
-     * @return <tt>true</tt> if this task was cancelled before it completed
+     * @return {@code true} if this task was cancelled before it completed
      */
     boolean isCancelled();
 
     /**
-     * Returns <tt>true</tt> if this task completed.
+     * Returns {@code true} if this task completed.
      *
      * Completion may be due to normal termination, an exception, or
      * cancellation -- in all of these cases, this method will return
-     * <tt>true</tt>.
+     * {@code true}.
      *
-     * @return <tt>true</tt> if this task completed
+     * @return {@code true} if this task completed
      */
     boolean isDone();
 

jdk/src/share/classes/java/util/concurrent/FutureTask.java

@@ -162,19 +162,23 @@ public class FutureTask<V> implements RunnableFuture<V> {
     }
 
     public boolean cancel(boolean mayInterruptIfRunning) {
-        if (state != NEW)
+        if (!(state == NEW &&
+              UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
+                  mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
             return false;
-        if (mayInterruptIfRunning) {
+        try {    // in case call to interrupt throws exception
-            if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING))
+            if (mayInterruptIfRunning) {
-                return false;
+                try {
-            Thread t = runner;
+                    Thread t = runner;
-            if (t != null)
+                    if (t != null)
-                t.interrupt();
+                        t.interrupt();
-            UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); // final state
+                } finally { // final state
+                    UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
+                }
+            }
+        } finally {
+            finishCompletion();
         }
-        else if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED))
-            return false;
-        finishCompletion();
         return true;
     }
 
@@ -288,7 +292,7 @@ public class FutureTask<V> implements RunnableFuture<V> {
      * designed for use with tasks that intrinsically execute more
      * than once.
      *
-     * @return true if successfully run and reset
+     * @return {@code true} if successfully run and reset
      */
     protected boolean runAndReset() {
         if (state != NEW ||

jdk/src/share/classes/java/util/concurrent/RecursiveAction.java

@@ -63,7 +63,7 @@ package java.util.concurrent;
  *     }
  *   }
  *   // implementation details follow:
- *   final static int THRESHOLD = 1000;
+ *   static final int THRESHOLD = 1000;
  *   void sortSequentially(int lo, int hi) {
  *     Arrays.sort(array, lo, hi);
  *   }
@@ -140,21 +140,21 @@ package java.util.concurrent;
  *     int h = hi;
  *     Applyer right = null;
  *     while (h - l > 1 && getSurplusQueuedTaskCount() <= 3) {
- *        int mid = (l + h) >>> 1;
+ *       int mid = (l + h) >>> 1;
- *        right = new Applyer(array, mid, h, right);
+ *       right = new Applyer(array, mid, h, right);
- *        right.fork();
+ *       right.fork();
- *        h = mid;
+ *       h = mid;
  *     }
  *     double sum = atLeaf(l, h);
  *     while (right != null) {
- *        if (right.tryUnfork()) // directly calculate if not stolen
+ *       if (right.tryUnfork()) // directly calculate if not stolen
- *          sum += right.atLeaf(right.lo, right.hi);
+ *         sum += right.atLeaf(right.lo, right.hi);
  *       else {
- *          right.join();
+ *         right.join();
- *          sum += right.result;
+ *         sum += right.result;
- *        }
+ *       }
- *        right = right.next;
+ *       right = right.next;
- *      }
+ *     }
  *     result = sum;
  *   }
  * }}</pre>

jdk/src/share/classes/java/util/concurrent/RecursiveTask.java

@@ -46,7 +46,7 @@ package java.util.concurrent;
  *   Fibonacci(int n) { this.n = n; }
  *   Integer compute() {
  *     if (n <= 1)
- *        return n;
+ *       return n;
  *     Fibonacci f1 = new Fibonacci(n - 1);
  *     f1.fork();
  *     Fibonacci f2 = new Fibonacci(n - 2);
@@ -75,6 +75,7 @@ public abstract class RecursiveTask<V> extends ForkJoinTask<V> {
 
     /**
      * The main computation performed by this task.
+     * @return the result of the computation
      */
     protected abstract V compute();
 

jdk/src/share/classes/java/util/concurrent/RejectedExecutionException.java

@@ -46,14 +46,14 @@ public class RejectedExecutionException extends RuntimeException {
     private static final long serialVersionUID = -375805702767069545L;
 
     /**
-     * Constructs a <tt>RejectedExecutionException</tt> with no detail message.
+     * Constructs a {@code RejectedExecutionException} with no detail message.
      * The cause is not initialized, and may subsequently be
      * initialized by a call to {@link #initCause(Throwable) initCause}.
      */
     public RejectedExecutionException() { }
 
     /**
-     * Constructs a <tt>RejectedExecutionException</tt> with the
+     * Constructs a {@code RejectedExecutionException} with the
      * specified detail message. The cause is not initialized, and may
      * subsequently be initialized by a call to {@link
      * #initCause(Throwable) initCause}.
@@ -65,7 +65,7 @@ public class RejectedExecutionException extends RuntimeException {
     }
 
     /**
-     * Constructs a <tt>RejectedExecutionException</tt> with the
+     * Constructs a {@code RejectedExecutionException} with the
      * specified detail message and cause.
      *
      * @param  message the detail message
@@ -77,10 +77,10 @@ public class RejectedExecutionException extends RuntimeException {
     }
 
     /**
-     * Constructs a <tt>RejectedExecutionException</tt> with the
+     * Constructs a {@code RejectedExecutionException} with the
      * specified cause.  The detail message is set to {@code (cause ==
      * null ? null : cause.toString())} (which typically contains
-     * the class and detail message of <tt>cause</tt>).
+     * the class and detail message of {@code cause}).
      *
      * @param  cause the cause (which is saved for later retrieval by the
      *         {@link #getCause()} method)

jdk/src/share/classes/java/util/concurrent/RunnableFuture.java

@@ -37,13 +37,13 @@ package java.util.concurrent;
 
 /**
  * A {@link Future} that is {@link Runnable}. Successful execution of
- * the <tt>run</tt> method causes completion of the <tt>Future</tt>
+ * the {@code run} method causes completion of the {@code Future}
  * and allows access to its results.
  * @see FutureTask
  * @see Executor
  * @since 1.6
  * @author Doug Lea
- * @param <V> The result type returned by this Future's <tt>get</tt> method
+ * @param <V> The result type returned by this Future's {@code get} method
  */
 public interface RunnableFuture<V> extends Runnable, Future<V> {
     /**

jdk/src/share/classes/java/util/concurrent/RunnableScheduledFuture.java

@@ -37,22 +37,22 @@ package java.util.concurrent;
 
 /**
  * A {@link ScheduledFuture} that is {@link Runnable}. Successful
- * execution of the <tt>run</tt> method causes completion of the
+ * execution of the {@code run} method causes completion of the
- * <tt>Future</tt> and allows access to its results.
+ * {@code Future} and allows access to its results.
  * @see FutureTask
  * @see Executor
  * @since 1.6
  * @author Doug Lea
- * @param <V> The result type returned by this Future's <tt>get</tt> method
+ * @param <V> The result type returned by this Future's {@code get} method
  */
 public interface RunnableScheduledFuture<V> extends RunnableFuture<V>, ScheduledFuture<V> {
 
     /**
-     * Returns true if this is a periodic task. A periodic task may
+     * Returns {@code true} if this task is periodic. A periodic task may
      * re-run according to some schedule. A non-periodic task can be
      * run only once.
      *
-     * @return true if this task is periodic
+     * @return {@code true} if this task is periodic
      */
     boolean isPeriodic();
 }

jdk/src/share/classes/java/util/concurrent/ScheduledExecutorService.java

@@ -39,30 +39,30 @@ package java.util.concurrent;
  * An {@link ExecutorService} that can schedule commands to run after a given
  * delay, or to execute periodically.
  *
- * <p> The <tt>schedule</tt> methods create tasks with various delays
+ * <p>The {@code schedule} methods create tasks with various delays
  * and return a task object that can be used to cancel or check
- * execution. The <tt>scheduleAtFixedRate</tt> and
+ * execution. The {@code scheduleAtFixedRate} and
- * <tt>scheduleWithFixedDelay</tt> methods create and execute tasks
+ * {@code scheduleWithFixedDelay} methods create and execute tasks
  * that run periodically until cancelled.
  *
- * <p> Commands submitted using the {@link Executor#execute} and
+ * <p>Commands submitted using the {@link Executor#execute(Runnable)}
- * {@link ExecutorService} <tt>submit</tt> methods are scheduled with
+ * and {@link ExecutorService} {@code submit} methods are scheduled
- * a requested delay of zero. Zero and negative delays (but not
+ * with a requested delay of zero. Zero and negative delays (but not
- * periods) are also allowed in <tt>schedule</tt> methods, and are
+ * periods) are also allowed in {@code schedule} methods, and are
  * treated as requests for immediate execution.
  *
- * <p>All <tt>schedule</tt> methods accept <em>relative</em> delays and
+ * <p>All {@code schedule} methods accept <em>relative</em> delays and
  * periods as arguments, not absolute times or dates. It is a simple
  * matter to transform an absolute time represented as a {@link
  * java.util.Date} to the required form. For example, to schedule at
- * a certain future <tt>date</tt>, you can use: <tt>schedule(task,
+ * a certain future {@code date}, you can use: {@code schedule(task,
  * date.getTime() - System.currentTimeMillis(),
- * TimeUnit.MILLISECONDS)</tt>. Beware however that expiration of a
+ * TimeUnit.MILLISECONDS)}. Beware however that expiration of a
- * relative delay need not coincide with the current <tt>Date</tt> at
+ * relative delay need not coincide with the current {@code Date} at
  * which the task is enabled due to network time synchronization
  * protocols, clock drift, or other factors.
  *
- * The {@link Executors} class provides convenient factory methods for
+ * <p>The {@link Executors} class provides convenient factory methods for
  * the ScheduledExecutorService implementations provided in this package.
  *
  * <h3>Usage Example</h3>
@@ -101,8 +101,8 @@ public interface ScheduledExecutorService extends ExecutorService {
      * @param delay the time from now to delay execution
      * @param unit the time unit of the delay parameter
      * @return a ScheduledFuture representing pending completion of
-     *         the task and whose <tt>get()</tt> method will return
+     *         the task and whose {@code get()} method will return
-     *         <tt>null</tt> upon completion
+     *         {@code null} upon completion
      * @throws RejectedExecutionException if the task cannot be
      *         scheduled for execution
      * @throws NullPointerException if command is null
@@ -129,8 +129,8 @@ public interface ScheduledExecutorService extends ExecutorService {
      * Creates and executes a periodic action that becomes enabled first
      * after the given initial delay, and subsequently with the given
      * period; that is executions will commence after
-     * <tt>initialDelay</tt> then <tt>initialDelay+period</tt>, then
+     * {@code initialDelay} then {@code initialDelay+period}, then
-     * <tt>initialDelay + 2 * period</tt>, and so on.
+     * {@code initialDelay + 2 * period}, and so on.
      * If any execution of the task
      * encounters an exception, subsequent executions are suppressed.
      * Otherwise, the task will only terminate via cancellation or
@@ -143,7 +143,7 @@ public interface ScheduledExecutorService extends ExecutorService {
      * @param period the period between successive executions
      * @param unit the time unit of the initialDelay and period parameters
      * @return a ScheduledFuture representing pending completion of
-     *         the task, and whose <tt>get()</tt> method will throw an
+     *         the task, and whose {@code get()} method will throw an
      *         exception upon cancellation
      * @throws RejectedExecutionException if the task cannot be
      *         scheduled for execution
@@ -170,7 +170,7 @@ public interface ScheduledExecutorService extends ExecutorService {
      * execution and the commencement of the next
      * @param unit the time unit of the initialDelay and delay parameters
      * @return a ScheduledFuture representing pending completion of
-     *         the task, and whose <tt>get()</tt> method will throw an
+     *         the task, and whose {@code get()} method will throw an
      *         exception upon cancellation
      * @throws RejectedExecutionException if the task cannot be
      *         scheduled for execution

jdk/src/share/classes/java/util/concurrent/ScheduledThreadPoolExecutor.java

@@ -81,7 +81,7 @@ import java.util.*;
  * without threads to handle tasks once they become eligible to run.
  *
  * <p><b>Extension notes:</b> This class overrides the
- * {@link ThreadPoolExecutor#execute execute} and
+ * {@link ThreadPoolExecutor#execute(Runnable) execute} and
  * {@link AbstractExecutorService#submit(Runnable) submit}
  * methods to generate internal {@link ScheduledFuture} objects to
  * control per-task delays and scheduling.  To preserve
@@ -256,9 +256,9 @@ public class ScheduledThreadPoolExecutor
         }
 
         /**
-         * Returns true if this is a periodic (not a one-shot) action.
+         * Returns {@code true} if this is a periodic (not a one-shot) action.
          *
-         * @return true if periodic
+         * @return {@code true} if periodic
          */
         public boolean isPeriodic() {
             return period != 0;
@@ -315,7 +315,7 @@ public class ScheduledThreadPoolExecutor
      * is shut down, rejects the task. Otherwise adds task to queue
      * and starts a thread, if necessary, to run it.  (We cannot
      * prestart the thread to run the task because the task (probably)
-     * shouldn't be run yet,) If the pool is shut down while the task
+     * shouldn't be run yet.)  If the pool is shut down while the task
      * is being added, cancel and remove it if required by state and
      * run-after-shutdown parameters.
      *
@@ -654,7 +654,7 @@ public class ScheduledThreadPoolExecutor
      * {@code false} when already shutdown.
      * This value is by default {@code false}.
      *
-     * @param value if {@code true}, continue after shutdown, else don't.
+     * @param value if {@code true}, continue after shutdown, else don't
      * @see #getContinueExistingPeriodicTasksAfterShutdownPolicy
      */
     public void setContinueExistingPeriodicTasksAfterShutdownPolicy(boolean value) {
@@ -686,7 +686,7 @@ public class ScheduledThreadPoolExecutor
      * {@code false} when already shutdown.
      * This value is by default {@code true}.
      *
-     * @param value if {@code true}, execute after shutdown, else don't.
+     * @param value if {@code true}, execute after shutdown, else don't
      * @see #getExecuteExistingDelayedTasksAfterShutdownPolicy
      */
     public void setExecuteExistingDelayedTasksAfterShutdownPolicy(boolean value) {
@@ -1081,7 +1081,8 @@ public class ScheduledThreadPoolExecutor
                         long delay = first.getDelay(NANOSECONDS);
                         if (delay <= 0)
                             return finishPoll(first);
-                        else if (leader != null)
+                        first = null; // don't retain ref while waiting
+                        if (leader != null)
                             available.await();
                         else {
                             Thread thisThread = Thread.currentThread();
@@ -1121,6 +1122,7 @@ public class ScheduledThreadPoolExecutor
                             return finishPoll(first);
                         if (nanos <= 0)
                             return null;
+                        first = null; // don't retain ref while waiting
                         if (nanos < delay || leader != null)
                             nanos = available.awaitNanos(nanos);
                         else {

jdk/src/share/classes/java/util/concurrent/ThreadPoolExecutor.java

@@ -75,22 +75,23 @@ import java.util.*;
  * corePoolSize (see {@link #getCorePoolSize}) and
  * maximumPoolSize (see {@link #getMaximumPoolSize}).
  *
- * When a new task is submitted in method {@link #execute}, and fewer
+ * When a new task is submitted in method {@link #execute(Runnable)},
- * than corePoolSize threads are running, a new thread is created to
+ * and fewer than corePoolSize threads are running, a new thread is
- * handle the request, even if other worker threads are idle.  If
+ * created to handle the request, even if other worker threads are
- * there are more than corePoolSize but less than maximumPoolSize
+ * idle.  If there are more than corePoolSize but less than
- * threads running, a new thread will be created only if the queue is
+ * maximumPoolSize threads running, a new thread will be created only
- * full.  By setting corePoolSize and maximumPoolSize the same, you
+ * if the queue is full.  By setting corePoolSize and maximumPoolSize
- * create a fixed-size thread pool. By setting maximumPoolSize to an
+ * the same, you create a fixed-size thread pool. By setting
- * essentially unbounded value such as {@code Integer.MAX_VALUE}, you
+ * maximumPoolSize to an essentially unbounded value such as {@code
- * allow the pool to accommodate an arbitrary number of concurrent
+ * Integer.MAX_VALUE}, you allow the pool to accommodate an arbitrary
- * tasks. Most typically, core and maximum pool sizes are set only
+ * number of concurrent tasks. Most typically, core and maximum pool
- * upon construction, but they may also be changed dynamically using
+ * sizes are set only upon construction, but they may also be changed
- * {@link #setCorePoolSize} and {@link #setMaximumPoolSize}. </dd>
+ * dynamically using {@link #setCorePoolSize} and {@link
+ * #setMaximumPoolSize}. </dd>
  *
  * <dt>On-demand construction</dt>
  *
- * <dd> By default, even core threads are initially created and
+ * <dd>By default, even core threads are initially created and
  * started only when new tasks arrive, but this can be overridden
  * dynamically using method {@link #prestartCoreThread} or {@link
  * #prestartAllCoreThreads}.  You probably want to prestart threads if
@@ -117,17 +118,17 @@ import java.util.*;
  *
  * <dd>If the pool currently has more than corePoolSize threads,
  * excess threads will be terminated if they have been idle for more
- * than the keepAliveTime (see {@link #getKeepAliveTime}). This
+ * than the keepAliveTime (see {@link #getKeepAliveTime(TimeUnit)}).
- * provides a means of reducing resource consumption when the pool is
+ * This provides a means of reducing resource consumption when the
- * not being actively used. If the pool becomes more active later, new
+ * pool is not being actively used. If the pool becomes more active
- * threads will be constructed. This parameter can also be changed
+ * later, new threads will be constructed. This parameter can also be
- * dynamically using method {@link #setKeepAliveTime}. Using a value
+ * changed dynamically using method {@link #setKeepAliveTime(long,
- * of {@code Long.MAX_VALUE} {@link TimeUnit#NANOSECONDS} effectively
+ * TimeUnit)}.  Using a value of {@code Long.MAX_VALUE} {@link
- * disables idle threads from ever terminating prior to shut down. By
+ * TimeUnit#NANOSECONDS} effectively disables idle threads from ever
- * default, the keep-alive policy applies only when there are more
+ * terminating prior to shut down. By default, the keep-alive policy
- * than corePoolSizeThreads. But method {@link
+ * applies only when there are more than corePoolSize threads. But
- * #allowCoreThreadTimeOut(boolean)} can be used to apply this
+ * method {@link #allowCoreThreadTimeOut(boolean)} can be used to
- * time-out policy to core threads as well, so long as the
+ * apply this time-out policy to core threads as well, so long as the
  * keepAliveTime value is non-zero. </dd>
  *
  * <dt>Queuing</dt>
@@ -197,14 +198,14 @@ import java.util.*;
  *
  * <dt>Rejected tasks</dt>
  *
- * <dd> New tasks submitted in method {@link #execute} will be
+ * <dd>New tasks submitted in method {@link #execute(Runnable)} will be
- * <em>rejected</em> when the Executor has been shut down, and also
+ * <em>rejected</em> when the Executor has been shut down, and also when
- * when the Executor uses finite bounds for both maximum threads and
+ * the Executor uses finite bounds for both maximum threads and work queue
- * work queue capacity, and is saturated.  In either case, the {@code
+ * capacity, and is saturated.  In either case, the {@code execute} method
- * execute} method invokes the {@link
+ * invokes the {@link
- * RejectedExecutionHandler#rejectedExecution} method of its {@link
+ * RejectedExecutionHandler#rejectedExecution(Runnable, ThreadPoolExecutor)}
- * RejectedExecutionHandler}.  Four predefined handler policies are
+ * method of its {@link RejectedExecutionHandler}.  Four predefined handler
- * provided:
+ * policies are provided:
  *
  * <ol>
  *
@@ -234,30 +235,31 @@ import java.util.*;
  *
  * <dt>Hook methods</dt>
  *
- * <dd>This class provides {@code protected} overridable {@link
+ * <dd>This class provides {@code protected} overridable
- * #beforeExecute} and {@link #afterExecute} methods that are called
+ * {@link #beforeExecute(Thread, Runnable)} and
+ * {@link #afterExecute(Runnable, Throwable)} methods that are called
  * before and after execution of each task.  These can be used to
  * manipulate the execution environment; for example, reinitializing
- * ThreadLocals, gathering statistics, or adding log
+ * ThreadLocals, gathering statistics, or adding log entries.
- * entries. Additionally, method {@link #terminated} can be overridden
+ * Additionally, method {@link #terminated} can be overridden to perform
- * to perform any special processing that needs to be done once the
+ * any special processing that needs to be done once the Executor has
- * Executor has fully terminated.
+ * fully terminated.
  *
  * <p>If hook or callback methods throw exceptions, internal worker
  * threads may in turn fail and abruptly terminate.</dd>
  *
  * <dt>Queue maintenance</dt>
  *
- * <dd> Method {@link #getQueue} allows access to the work queue for
+ * <dd>Method {@link #getQueue()} allows access to the work queue
- * purposes of monitoring and debugging.  Use of this method for any
+ * for purposes of monitoring and debugging.  Use of this method for
- * other purpose is strongly discouraged.  Two supplied methods,
+ * any other purpose is strongly discouraged.  Two supplied methods,
- * {@link #remove} and {@link #purge} are available to assist in
+ * {@link #remove(Runnable)} and {@link #purge} are available to
- * storage reclamation when large numbers of queued tasks become
+ * assist in storage reclamation when large numbers of queued tasks
- * cancelled.</dd>
+ * become cancelled.</dd>
  *
  * <dt>Finalization</dt>
  *
- * <dd> A pool that is no longer referenced in a program <em>AND</em>
+ * <dd>A pool that is no longer referenced in a program <em>AND</em>
  * has no remaining threads will be {@code shutdown} automatically. If
  * you would like to ensure that unreferenced pools are reclaimed even
  * if users forget to call {@link #shutdown}, then you must arrange
@@ -267,7 +269,7 @@ import java.util.*;
  *
  * </dl>
  *
- * <p> <b>Extension example</b>. Most extensions of this class
+ * <p><b>Extension example</b>. Most extensions of this class
  * override one or more of the protected hook methods. For example,
  * here is a subclass that adds a simple pause/resume feature:
  *
@@ -336,7 +338,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * bookkeeping before terminating. The user-visible pool size is
      * reported as the current size of the workers set.
      *
-     * The runState provides the main lifecyle control, taking on values:
+     * The runState provides the main lifecycle control, taking on values:
      *
      *   RUNNING:  Accept new tasks and process queued tasks
      *   SHUTDOWN: Don't accept new tasks, but process queued tasks
@@ -406,14 +408,14 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
     }
 
     /**
-     * Attempt to CAS-increment the workerCount field of ctl.
+     * Attempts to CAS-increment the workerCount field of ctl.
      */
     private boolean compareAndIncrementWorkerCount(int expect) {
         return ctl.compareAndSet(expect, expect + 1);
     }
 
     /**
-     * Attempt to CAS-decrement the workerCount field of ctl.
+     * Attempts to CAS-decrement the workerCount field of ctl.
      */
     private boolean compareAndDecrementWorkerCount(int expect) {
         return ctl.compareAndSet(expect, expect - 1);
@@ -498,7 +500,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * We go further and preserve pool invariants even in the face of
      * errors such as OutOfMemoryError, that might be thrown while
      * trying to create threads.  Such errors are rather common due to
-     * the need to allocate a native stack in Thread#start, and users
+     * the need to allocate a native stack in Thread.start, and users
      * will want to perform clean pool shutdown to clean up.  There
      * will likely be enough memory available for the cleanup code to
      * complete without encountering yet another OutOfMemoryError.
@@ -848,7 +850,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      */
     private List<Runnable> drainQueue() {
         BlockingQueue<Runnable> q = workQueue;
-        List<Runnable> taskList = new ArrayList<Runnable>();
+        ArrayList<Runnable> taskList = new ArrayList<Runnable>();
         q.drainTo(taskList);
         if (!q.isEmpty()) {
             for (Runnable r : q.toArray(new Runnable[0])) {
@@ -873,7 +875,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * factory fails to create a thread when asked.  If the thread
      * creation fails, either due to the thread factory returning
      * null, or due to an exception (typically OutOfMemoryError in
-     * Thread#start), we roll back cleanly.
+     * Thread.start()), we roll back cleanly.
      *
      * @param firstTask the task the new thread should run first (or
      * null if none). Workers are created with an initial first task
@@ -920,17 +922,16 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
         boolean workerAdded = false;
         Worker w = null;
         try {
-            final ReentrantLock mainLock = this.mainLock;
             w = new Worker(firstTask);
             final Thread t = w.thread;
             if (t != null) {
+                final ReentrantLock mainLock = this.mainLock;
                 mainLock.lock();
                 try {
                     // Recheck while holding lock.
                     // Back out on ThreadFactory failure or if
                     // shut down before lock acquired.
-                    int c = ctl.get();
+                    int rs = runStateOf(ctl.get());
-                    int rs = runStateOf(c);
 
                     if (rs < SHUTDOWN ||
                         (rs == SHUTDOWN && firstTask == null)) {
@@ -1029,7 +1030,8 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * 4. This worker timed out waiting for a task, and timed-out
      *    workers are subject to termination (that is,
      *    {@code allowCoreThreadTimeOut || workerCount > corePoolSize})
-     *    both before and after the timed wait.
+     *    both before and after the timed wait, and if the queue is
+     *    non-empty, this worker is not the last thread in the pool.
      *
      * @return task, or null if the worker must exit, in which case
      *         workerCount is decremented
@@ -1037,7 +1039,6 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
     private Runnable getTask() {
         boolean timedOut = false; // Did the last poll() time out?
 
-        retry:
         for (;;) {
             int c = ctl.get();
             int rs = runStateOf(c);
@@ -1048,20 +1049,16 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
                 return null;
             }
 
-            boolean timed;      // Are workers subject to culling?
+            int wc = workerCountOf(c);
 
-            for (;;) {
+            // Are workers subject to culling?
-                int wc = workerCountOf(c);
+            boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;
-                timed = allowCoreThreadTimeOut || wc > corePoolSize;
 
-                if (wc <= maximumPoolSize && ! (timedOut && timed))
+            if ((wc > maximumPoolSize || (timed && timedOut))
-                    break;
+                && (wc > 1 || workQueue.isEmpty())) {
                 if (compareAndDecrementWorkerCount(c))
                     return null;
-                c = ctl.get();  // Re-read ctl
+                continue;
-                if (runStateOf(c) != rs)
-                    continue retry;
-                // else CAS failed due to workerCount change; retry inner loop
             }
 
             try {
@@ -1090,9 +1087,9 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * usually leads processWorkerExit to replace this thread.
      *
      * 2. Before running any task, the lock is acquired to prevent
-     * other pool interrupts while the task is executing, and
+     * other pool interrupts while the task is executing, and then we
-     * clearInterruptsForTaskRun called to ensure that unless pool is
+     * ensure that unless pool is stopping, this thread does not have
-     * stopping, this thread does not have its interrupt set.
+     * its interrupt set.
      *
      * 3. Each task run is preceded by a call to beforeExecute, which
      * might throw an exception, in which case we cause thread to die
@@ -1100,12 +1097,12 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * the task.
      *
      * 4. Assuming beforeExecute completes normally, we run the task,
-     * gathering any of its thrown exceptions to send to
+     * gathering any of its thrown exceptions to send to afterExecute.
-     * afterExecute. We separately handle RuntimeException, Error
+     * We separately handle RuntimeException, Error (both of which the
-     * (both of which the specs guarantee that we trap) and arbitrary
+     * specs guarantee that we trap) and arbitrary Throwables.
-     * Throwables.  Because we cannot rethrow Throwables within
+     * Because we cannot rethrow Throwables within Runnable.run, we
-     * Runnable.run, we wrap them within Errors on the way out (to the
+     * wrap them within Errors on the way out (to the thread's
-     * thread's UncaughtExceptionHandler).  Any thrown exception also
+     * UncaughtExceptionHandler).  Any thrown exception also
      * conservatively causes thread to die.
      *
      * 5. After task.run completes, we call afterExecute, which may
@@ -1443,7 +1440,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * ignored or suppressed interruption, causing this executor not
      * to properly terminate.
      *
-     * @return true if terminating but not yet terminated
+     * @return {@code true} if terminating but not yet terminated
      */
     public boolean isTerminating() {
         int c = ctl.get();
@@ -1497,7 +1494,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * Returns the thread factory used to create new threads.
      *
      * @return the current thread factory
-     * @see #setThreadFactory
+     * @see #setThreadFactory(ThreadFactory)
      */
     public ThreadFactory getThreadFactory() {
         return threadFactory;
@@ -1520,7 +1517,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * Returns the current handler for unexecutable tasks.
      *
      * @return the current handler
-     * @see #setRejectedExecutionHandler
+     * @see #setRejectedExecutionHandler(RejectedExecutionHandler)
      */
     public RejectedExecutionHandler getRejectedExecutionHandler() {
         return handler;
@@ -1692,7 +1689,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * @param unit the time unit of the {@code time} argument
      * @throws IllegalArgumentException if {@code time} less than zero or
      *         if {@code time} is zero and {@code allowsCoreThreadTimeOut}
-     * @see #getKeepAliveTime
+     * @see #getKeepAliveTime(TimeUnit)
      */
     public void setKeepAliveTime(long time, TimeUnit unit) {
         if (time < 0)
@@ -1713,7 +1710,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      *
      * @param unit the desired time unit of the result
      * @return the time limit
-     * @see #setKeepAliveTime
+     * @see #setKeepAliveTime(long, TimeUnit)
      */
     public long getKeepAliveTime(TimeUnit unit) {
         return unit.convert(keepAliveTime, TimeUnit.NANOSECONDS);
@@ -1738,7 +1735,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * present, thus causing it not to be run if it has not already
      * started.
      *
-     * <p> This method may be useful as one part of a cancellation
+     * <p>This method may be useful as one part of a cancellation
      * scheme.  It may fail to remove tasks that have been converted
      * into other forms before being placed on the internal queue. For
      * example, a task entered using {@code submit} might be
@@ -1747,7 +1744,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * remove those Futures that have been cancelled.
      *
      * @param task the task to remove
-     * @return true if the task was removed
+     * @return {@code true} if the task was removed
      */
     public boolean remove(Runnable task) {
         boolean removed = workQueue.remove(task);
@@ -2042,7 +2039,7 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
          *
          * @param r the runnable task requested to be executed
          * @param e the executor attempting to execute this task
-         * @throws RejectedExecutionException always.
+         * @throws RejectedExecutionException always
          */
         public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
             throw new RejectedExecutionException("Task " + r.toString() +
@@ -2099,4 +2096,3 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
         }
     }
 }
-

jdk/src/share/classes/java/util/regex/MatchResult.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2004, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -77,7 +77,7 @@ public interface MatchResult {
     public int start(int group);
 
     /**
-     * Returns the offset after the last character matched.  </p>
+     * Returns the offset after the last character matched.
      *
      * @return  The offset after the last character matched
      *

jdk/src/share/classes/java/util/regex/Matcher.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -28,8 +28,8 @@ package java.util.regex;
 import java.util.Objects;
 
 /**
- * An engine that performs match operations on a {@link java.lang.CharSequence
+ * An engine that performs match operations on a {@linkplain java.lang.CharSequence
- * </code>character sequence<code>} by interpreting a {@link Pattern}.
+ * character sequence} by interpreting a {@link Pattern}.
  *
  * <p> A matcher is created from a pattern by invoking the pattern's {@link
  * Pattern#matcher matcher} method.  Once created, a matcher can be used to
@@ -330,7 +330,7 @@ public final class Matcher implements MatchResult {
     }
 
     /**
-     * Returns the start index of the previous match.  </p>
+     * Returns the start index of the previous match.
      *
      * @return  The index of the first character matched
      *
@@ -402,7 +402,7 @@ public final class Matcher implements MatchResult {
     }
 
     /**
-     * Returns the offset after the last character matched.  </p>
+     * Returns the offset after the last character matched.
      *
      * @return  The offset after the last character matched
      *
@@ -647,6 +647,7 @@ public final class Matcher implements MatchResult {
      * invocations of the {@link #find()} method will start at the first
      * character not matched by this match.  </p>
      *
+     * @param start the index to start searching for a match
      * @throws  IndexOutOfBoundsException
      *          If start is less than zero or if start is greater than the
      *          length of the input sequence.
@@ -736,8 +737,8 @@ public final class Matcher implements MatchResult {
      * captured during the previous match: Each occurrence of
      * <tt>${</tt><i>name</i><tt>}</tt> or <tt>$</tt><i>g</i>
      * will be replaced by the result of evaluating the corresponding
-     * {@link #group(String) group(name)} or {@link #group(int) group(g)</tt>}
+     * {@link #group(String) group(name)} or {@link #group(int) group(g)}
-     * respectively. For  <tt>$</tt><i>g</i><tt></tt>,
+     * respectively. For  <tt>$</tt><i>g</i>,
      * the first number after the <tt>$</tt> is always treated as part of
      * the group reference. Subsequent numbers are incorporated into g if
      * they would form a legal group reference. Only the numerals '0'

jdk/src/share/classes/java/util/regex/Pattern.java

@@ -45,8 +45,8 @@ import java.util.stream.StreamSupport;
  *
  * <p> A regular expression, specified as a string, must first be compiled into
  * an instance of this class.  The resulting pattern can then be used to create
- * a {@link Matcher} object that can match arbitrary {@link
+ * a {@link Matcher} object that can match arbitrary {@linkplain
- * java.lang.CharSequence </code>character sequences<code>} against the regular
+ * java.lang.CharSequence character sequences} against the regular
  * expression.  All of the state involved in performing a match resides in the
  * matcher, so many matchers can share the same pattern.
  *
@@ -73,15 +73,14 @@ import java.util.stream.StreamSupport;
  * such use.
  *
  *
- * <a name="sum">
+ * <h3><a name="sum">Summary of regular-expression constructs</a></h3>
- * <h4> Summary of regular-expression constructs </h4>
  *
  * <table border="0" cellpadding="1" cellspacing="0"
  *  summary="Regular expression constructs, and what they match">
  *
  * <tr align="left">
- * <th bgcolor="#CCCCFF" align="left" id="construct">Construct</th>
+ * <th align="left" id="construct">Construct</th>
- * <th bgcolor="#CCCCFF" align="left" id="matches">Matches</th>
+ * <th align="left" id="matches">Matches</th>
  * </tr>
  *
  * <tr><th>&nbsp;</th></tr>
@@ -128,24 +127,24 @@ import java.util.stream.StreamSupport;
  * <tr><th>&nbsp;</th></tr>
  * <tr align="left"><th colspan="2" id="classes">Character classes</th></tr>
  *
- * <tr><td valign="top" headers="construct classes"><tt>[abc]</tt></td>
+ * <tr><td valign="top" headers="construct classes">{@code [abc]}</td>
- *     <td headers="matches"><tt>a</tt>, <tt>b</tt>, or <tt>c</tt> (simple class)</td></tr>
+ *     <td headers="matches">{@code a}, {@code b}, or {@code c} (simple class)</td></tr>
- * <tr><td valign="top" headers="construct classes"><tt>[^abc]</tt></td>
+ * <tr><td valign="top" headers="construct classes">{@code [^abc]}</td>
- *     <td headers="matches">Any character except <tt>a</tt>, <tt>b</tt>, or <tt>c</tt> (negation)</td></tr>
+ *     <td headers="matches">Any character except {@code a}, {@code b}, or {@code c} (negation)</td></tr>
- * <tr><td valign="top" headers="construct classes"><tt>[a-zA-Z]</tt></td>
+ * <tr><td valign="top" headers="construct classes">{@code [a-zA-Z]}</td>
- *     <td headers="matches"><tt>a</tt> through <tt>z</tt>
+ *     <td headers="matches">{@code a} through {@code z}
- *         or <tt>A</tt> through <tt>Z</tt>, inclusive (range)</td></tr>
+ *         or {@code A} through {@code Z}, inclusive (range)</td></tr>
- * <tr><td valign="top" headers="construct classes"><tt>[a-d[m-p]]</tt></td>
+ * <tr><td valign="top" headers="construct classes">{@code [a-d[m-p]]}</td>
- *     <td headers="matches"><tt>a</tt> through <tt>d</tt>,
+ *     <td headers="matches">{@code a} through {@code d},
- *      or <tt>m</tt> through <tt>p</tt>: <tt>[a-dm-p]</tt> (union)</td></tr>
+ *      or {@code m} through {@code p}: {@code [a-dm-p]} (union)</td></tr>
- * <tr><td valign="top" headers="construct classes"><tt>[a-z&&[def]]</tt></td>
+ * <tr><td valign="top" headers="construct classes">{@code [a-z&&[def]]}</td>
- *     <td headers="matches"><tt>d</tt>, <tt>e</tt>, or <tt>f</tt> (intersection)</tr>
+ *     <td headers="matches">{@code d}, {@code e}, or {@code f} (intersection)</tr>
- * <tr><td valign="top" headers="construct classes"><tt>[a-z&&[^bc]]</tt></td>
+ * <tr><td valign="top" headers="construct classes">{@code [a-z&&[^bc]]}</td>
- *     <td headers="matches"><tt>a</tt> through <tt>z</tt>,
+ *     <td headers="matches">{@code a} through {@code z},
- *         except for <tt>b</tt> and <tt>c</tt>: <tt>[ad-z]</tt> (subtraction)</td></tr>
+ *         except for {@code b} and {@code c}: {@code [ad-z]} (subtraction)</td></tr>
- * <tr><td valign="top" headers="construct classes"><tt>[a-z&&[^m-p]]</tt></td>
+ * <tr><td valign="top" headers="construct classes">{@code [a-z&&[^m-p]]}</td>
- *     <td headers="matches"><tt>a</tt> through <tt>z</tt>,
+ *     <td headers="matches">{@code a} through {@code z},
- *          and not <tt>m</tt> through <tt>p</tt>: <tt>[a-lq-z]</tt>(subtraction)</td></tr>
+ *          and not {@code m} through {@code p}: {@code [a-lq-z]}(subtraction)</td></tr>
  * <tr><th>&nbsp;</th></tr>
  *
  * <tr align="left"><th colspan="2" id="predef">Predefined character classes</th></tr>
@@ -175,36 +174,36 @@ import java.util.stream.StreamSupport;
  * <tr><td valign="top" headers="construct predef"><tt>\W</tt></td>
  *     <td headers="matches">A non-word character: <tt>[^\w]</tt></td></tr>
  * <tr><th>&nbsp;</th></tr>
- * <tr align="left"><th colspan="2" id="posix">POSIX character classes</b> (US-ASCII only)<b></th></tr>
+ * <tr align="left"><th colspan="2" id="posix"><b>POSIX character classes (US-ASCII only)</b></th></tr>
  *
- * <tr><td valign="top" headers="construct posix"><tt>\p{Lower}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Lower}}</td>
- *     <td headers="matches">A lower-case alphabetic character: <tt>[a-z]</tt></td></tr>
+ *     <td headers="matches">A lower-case alphabetic character: {@code [a-z]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{Upper}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Upper}}</td>
- *     <td headers="matches">An upper-case alphabetic character:<tt>[A-Z]</tt></td></tr>
+ *     <td headers="matches">An upper-case alphabetic character:{@code [A-Z]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{ASCII}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{ASCII}}</td>
- *     <td headers="matches">All ASCII:<tt>[\x00-\x7F]</tt></td></tr>
+ *     <td headers="matches">All ASCII:{@code [\x00-\x7F]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{Alpha}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Alpha}}</td>
- *     <td headers="matches">An alphabetic character:<tt>[\p{Lower}\p{Upper}]</tt></td></tr>
+ *     <td headers="matches">An alphabetic character:{@code [\p{Lower}\p{Upper}]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{Digit}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Digit}}</td>
- *     <td headers="matches">A decimal digit: <tt>[0-9]</tt></td></tr>
+ *     <td headers="matches">A decimal digit: {@code [0-9]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{Alnum}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Alnum}}</td>
- *     <td headers="matches">An alphanumeric character:<tt>[\p{Alpha}\p{Digit}]</tt></td></tr>
+ *     <td headers="matches">An alphanumeric character:{@code [\p{Alpha}\p{Digit}]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{Punct}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Punct}}</td>
- *     <td headers="matches">Punctuation: One of <tt>!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~</tt></td></tr>
+ *     <td headers="matches">Punctuation: One of {@code !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~}</td></tr>
- *     <!-- <tt>[\!"#\$%&'\(\)\*\+,\-\./:;\<=\>\?@\[\\\]\^_`\{\|\}~]</tt>
+ *     <!-- {@code [\!"#\$%&'\(\)\*\+,\-\./:;\<=\>\?@\[\\\]\^_`\{\|\}~]}
- *          <tt>[\X21-\X2F\X31-\X40\X5B-\X60\X7B-\X7E]</tt> -->
+ *          {@code [\X21-\X2F\X31-\X40\X5B-\X60\X7B-\X7E]} -->
- * <tr><td valign="top" headers="construct posix"><tt>\p{Graph}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Graph}}</td>
- *     <td headers="matches">A visible character: <tt>[\p{Alnum}\p{Punct}]</tt></td></tr>
+ *     <td headers="matches">A visible character: {@code [\p{Alnum}\p{Punct}]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{Print}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Print}}</td>
- *     <td headers="matches">A printable character: <tt>[\p{Graph}\x20]</tt></td></tr>
+ *     <td headers="matches">A printable character: {@code [\p{Graph}\x20]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{Blank}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Blank}}</td>
- *     <td headers="matches">A space or a tab: <tt>[ \t]</tt></td></tr>
+ *     <td headers="matches">A space or a tab: {@code [ \t]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{Cntrl}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Cntrl}}</td>
- *     <td headers="matches">A control character: <tt>[\x00-\x1F\x7F]</tt></td></tr>
+ *     <td headers="matches">A control character: {@code [\x00-\x1F\x7F]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{XDigit}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{XDigit}}</td>
- *     <td headers="matches">A hexadecimal digit: <tt>[0-9a-fA-F]</tt></td></tr>
+ *     <td headers="matches">A hexadecimal digit: {@code [0-9a-fA-F]}</td></tr>
- * <tr><td valign="top" headers="construct posix"><tt>\p{Space}</tt></td>
+ * <tr><td valign="top" headers="construct posix">{@code \p{Space}}</td>
- *     <td headers="matches">A whitespace character: <tt>[ \t\n\x0B\f\r]</tt></td></tr>
+ *     <td headers="matches">A whitespace character: {@code [ \t\n\x0B\f\r]}</td></tr>
  *
  * <tr><th>&nbsp;</th></tr>
  * <tr align="left"><th colspan="2">java.lang.Character classes (simple <a href="#jcc">java character type</a>)</th></tr>
@@ -220,19 +219,19 @@ import java.util.stream.StreamSupport;
  *
  * <tr><th>&nbsp;</th></tr>
  * <tr align="left"><th colspan="2" id="unicode">Classes for Unicode scripts, blocks, categories and binary properties</th></tr>
- * * <tr><td valign="top" headers="construct unicode"><tt>\p{IsLatin}</tt></td>
+ * * <tr><td valign="top" headers="construct unicode">{@code \p{IsLatin}}</td>
  *     <td headers="matches">A Latin&nbsp;script character (<a href="#usc">script</a>)</td></tr>
- * <tr><td valign="top" headers="construct unicode"><tt>\p{InGreek}</tt></td>
+ * <tr><td valign="top" headers="construct unicode">{@code \p{InGreek}}</td>
  *     <td headers="matches">A character in the Greek&nbsp;block (<a href="#ubc">block</a>)</td></tr>
- * <tr><td valign="top" headers="construct unicode"><tt>\p{Lu}</tt></td>
+ * <tr><td valign="top" headers="construct unicode">{@code \p{Lu}}</td>
  *     <td headers="matches">An uppercase letter (<a href="#ucc">category</a>)</td></tr>
- * <tr><td valign="top" headers="construct unicode"><tt>\p{IsAlphabetic}</tt></td>
+ * <tr><td valign="top" headers="construct unicode">{@code \p{IsAlphabetic}}</td>
  *     <td headers="matches">An alphabetic character (<a href="#ubpc">binary property</a>)</td></tr>
- * <tr><td valign="top" headers="construct unicode"><tt>\p{Sc}</tt></td>
+ * <tr><td valign="top" headers="construct unicode">{@code \p{Sc}}</td>
  *     <td headers="matches">A currency symbol</td></tr>
- * <tr><td valign="top" headers="construct unicode"><tt>\P{InGreek}</tt></td>
+ * <tr><td valign="top" headers="construct unicode">{@code \P{InGreek}}</td>
  *     <td headers="matches">Any character except one in the Greek block (negation)</td></tr>
- * <tr><td valign="top" headers="construct unicode"><tt>[\p{L}&&[^\p{Lu}]]&nbsp;</tt></td>
+ * <tr><td valign="top" headers="construct unicode">{@code [\p{L}&&[^\p{Lu}]]}</td>
  *     <td headers="matches">Any letter except an uppercase letter (subtraction)</td></tr>
  *
  * <tr><th>&nbsp;</th></tr>
@@ -376,8 +375,7 @@ import java.util.stream.StreamSupport;
  * <hr>
  *
  *
- * <a name="bs">
+ * <h3><a name="bs">Backslashes, escapes, and quoting</a></h3>
- * <h4> Backslashes, escapes, and quoting </h4>
  *
  * <p> The backslash character (<tt>'\'</tt>) serves to introduce escaped
  * constructs, as defined in the table above, as well as to quote characters
@@ -405,8 +403,7 @@ import java.util.stream.StreamSupport;
  * <tt>(hello)</tt> the string literal <tt>"&#92;&#92;(hello&#92;&#92;)"</tt>
  * must be used.
  *
- * <a name="cc">
+ * <h3><a name="cc">Character Classes</a></h3>
- * <h4> Character Classes </h4>
  *
  *    <p> Character classes may appear within other character classes, and
  *    may be composed by the union operator (implicit) and the intersection
@@ -435,7 +432,7 @@ import java.util.stream.StreamSupport;
  *        <td><tt>[a-e][i-u]</tt></td></tr>
  *      <tr><th>5&nbsp;&nbsp;&nbsp;&nbsp;</th>
  *        <td>Intersection</td>
- *        <td><tt>[a-z&&[aeiou]]</tt></td></tr>
+ *        <td>{@code [a-z&&[aeiou]]}</td></tr>
  *    </table></blockquote>
  *
  *    <p> Note that a different set of metacharacters are in effect inside
@@ -444,8 +441,7 @@ import java.util.stream.StreamSupport;
  *    character class, while the expression <tt>-</tt> becomes a range
  *    forming metacharacter.
  *
- * <a name="lt">
+ * <h3><a name="lt">Line terminators</a></h3>
- * <h4> Line terminators </h4>
  *
  * <p> A <i>line terminator</i> is a one- or two-character sequence that marks
  * the end of a line of the input character sequence.  The following are
@@ -480,11 +476,9 @@ import java.util.stream.StreamSupport;
  * except at the end of input. When in {@link #MULTILINE} mode <tt>$</tt>
  * matches just before a line terminator or the end of the input sequence.
  *
- * <a name="cg">
+ * <h3><a name="cg">Groups and capturing</a></h3>
- * <h4> Groups and capturing </h4>
  *
- * <a name="gnumber">
+ * <h4><a name="gnumber">Group number</a></h4>
- * <h5> Group number </h5>
  * <p> Capturing groups are numbered by counting their opening parentheses from
  * left to right.  In the expression <tt>((A)(B(C)))</tt>, for example, there
  * are four such groups: </p>
@@ -507,8 +501,7 @@ import java.util.stream.StreamSupport;
  * subsequence may be used later in the expression, via a back reference, and
  * may also be retrieved from the matcher once the match operation is complete.
  *
- * <a name="groupname">
+ * <h4><a name="groupname">Group name</a></h4>
- * <h5> Group name </h5>
  * <p>A capturing group can also be assigned a "name", a <tt>named-capturing group</tt>,
  * and then be back-referenced later by the "name". Group names are composed of
  * the following characters. The first character must be a <tt>letter</tt>.
@@ -537,7 +530,7 @@ import java.util.stream.StreamSupport;
  * that do not capture text and do not count towards the group total, or
  * <i>named-capturing</i> group.
  *
- * <h4> Unicode support </h4>
+ * <h3> Unicode support </h3>
  *
  * <p> This class is in conformance with Level 1 of <a
  * href="http://www.unicode.org/reports/tr18/"><i>Unicode Technical
@@ -568,18 +561,18 @@ import java.util.stream.StreamSupport;
  * <p>
  * Scripts, blocks, categories and binary properties can be used both inside
  * and outside of a character class.
- * <a name="usc">
+ *
  * <p>
- * <b>Scripts</b> are specified either with the prefix {@code Is}, as in
+ * <b><a name="usc">Scripts</a></b> are specified either with the prefix {@code Is}, as in
  * {@code IsHiragana}, or by using  the {@code script} keyword (or its short
  * form {@code sc})as in {@code script=Hiragana} or {@code sc=Hiragana}.
  * <p>
  * The script names supported by <code>Pattern</code> are the valid script names
  * accepted and defined by
  * {@link java.lang.Character.UnicodeScript#forName(String) UnicodeScript.forName}.
- * <a name="ubc">
+ *
  * <p>
- * <b>Blocks</b> are specified with the prefix {@code In}, as in
+ * <b><a name="ubc">Blocks</a></b> are specified with the prefix {@code In}, as in
  * {@code InMongolian}, or by using the keyword {@code block} (or its short
  * form {@code blk}) as in {@code block=Mongolian} or {@code blk=Mongolian}.
  * <p>
@@ -587,8 +580,8 @@ import java.util.stream.StreamSupport;
  * accepted and defined by
  * {@link java.lang.Character.UnicodeBlock#forName(String) UnicodeBlock.forName}.
  * <p>
- * <a name="ucc">
+ *
- * <b>Categories</b> may be specified with the optional prefix {@code Is}:
+ * <b><a name="ucc">Categories</a></b> may be specified with the optional prefix {@code Is}:
  * Both {@code \p{L}} and {@code \p{IsL}} denote the category of Unicode
  * letters. Same as scripts and blocks, categories can also be specified
  * by using the keyword {@code general_category} (or its short form
@@ -600,8 +593,8 @@ import java.util.stream.StreamSupport;
  * {@link java.lang.Character Character} class. The category names are those
  * defined in the Standard, both normative and informative.
  * <p>
- * <a name="ubpc">
+ *
- * <b>Binary properties</b> are specified with the prefix {@code Is}, as in
+ * <b><a name="ubpc">Binary properties</a></b> are specified with the prefix {@code Is}, as in
  * {@code IsAlphabetic}. The supported binary properties by <code>Pattern</code>
  * are
  * <ul>
@@ -629,8 +622,8 @@ import java.util.stream.StreamSupport;
  * <table border="0" cellpadding="1" cellspacing="0"
  *  summary="predefined and posix character classes in Unicode mode">
  * <tr align="left">
- * <th bgcolor="#CCCCFF" align="left" id="classes">Classes</th>
+ * <th align="left" id="predef_classes">Classes</th>
- * <th bgcolor="#CCCCFF" align="left" id="matches">Matches</th>
+ * <th align="left" id="predef_matches">Matches</th>
  *</tr>
  * <tr><td><tt>\p{Lower}</tt></td>
  *     <td>A lowercase character:<tt>\p{IsLowercase}</tt></td></tr>
@@ -649,9 +642,9 @@ import java.util.stream.StreamSupport;
  * <tr><td><tt>\p{Graph}</tt></td>
  *     <td>A visible character: <tt>[^\p{IsWhite_Space}\p{gc=Cc}\p{gc=Cs}\p{gc=Cn}]</tt></td></tr>
  * <tr><td><tt>\p{Print}</tt></td>
- *     <td>A printable character: <tt>[\p{Graph}\p{Blank}&&[^\p{Cntrl}]]</tt></td></tr>
+ *     <td>A printable character: {@code [\p{Graph}\p{Blank}&&[^\p{Cntrl}]]}</td></tr>
  * <tr><td><tt>\p{Blank}</tt></td>
- *     <td>A space or a tab: <tt>[\p{IsWhite_Space}&&[^\p{gc=Zl}\p{gc=Zp}\x0a\x0b\x0c\x0d\x85]]</tt></td></tr>
+ *     <td>A space or a tab: {@code [\p{IsWhite_Space}&&[^\p{gc=Zl}\p{gc=Zp}\x0a\x0b\x0c\x0d\x85]]}</td></tr>
  * <tr><td><tt>\p{Cntrl}</tt></td>
  *     <td>A control character: <tt>\p{gc=Cc}</tt></td></tr>
  * <tr><td><tt>\p{XDigit}</tt></td>
@@ -676,9 +669,9 @@ import java.util.stream.StreamSupport;
  * Categories that behave like the java.lang.Character
  * boolean is<i>methodname</i> methods (except for the deprecated ones) are
  * available through the same <tt>\p{</tt><i>prop</i><tt>}</tt> syntax where
- * the specified property has the name <tt>java<i>methodname</i></tt>.
+ * the specified property has the name <tt>java<i>methodname</i></tt></a>.
  *
- * <h4> Comparison to Perl 5 </h4>
+ * <h3> Comparison to Perl 5 </h3>
  *
  * <p>The <code>Pattern</code> engine performs traditional NFA-based matching
  * with ordered alternation as occurs in Perl 5.
@@ -1023,11 +1016,11 @@ public final class Pattern
     private transient boolean hasSupplementary;
 
     /**
-     * Compiles the given regular expression into a pattern.  </p>
+     * Compiles the given regular expression into a pattern.
      *
      * @param  regex
      *         The expression to be compiled
-     *
+     * @return the given regular expression compiled into a pattern
      * @throws  PatternSyntaxException
      *          If the expression's syntax is invalid
      */
@@ -1037,7 +1030,7 @@ public final class Pattern
 
     /**
      * Compiles the given regular expression into a pattern with the given
-     * flags.  </p>
+     * flags.
      *
      * @param  regex
      *         The expression to be compiled
@@ -1049,6 +1042,7 @@ public final class Pattern
      *         {@link #LITERAL}, {@link #UNICODE_CHARACTER_CLASS}
      *         and {@link #COMMENTS}
      *
+     * @return the given regular expression compiled into a pattern with the given flags
      * @throws  IllegalArgumentException
      *          If bit values other than those corresponding to the defined
      *          match flags are set in <tt>flags</tt>
@@ -1062,7 +1056,6 @@ public final class Pattern
 
     /**
      * Returns the regular expression from which this pattern was compiled.
-     * </p>
      *
      * @return  The source of this pattern
      */
@@ -1084,7 +1077,6 @@ public final class Pattern
 
     /**
      * Creates a matcher that will match the given input against this pattern.
-     * </p>
      *
      * @param  input
      *         The character sequence to be matched
@@ -1103,7 +1095,7 @@ public final class Pattern
     }
 
     /**
-     * Returns this pattern's match flags.  </p>
+     * Returns this pattern's match flags.
      *
      * @return  The match flags specified when this pattern was compiled
      */
@@ -1133,7 +1125,7 @@ public final class Pattern
      *
      * @param  input
      *         The character sequence to be matched
-     *
+     * @return whether or not the regular expression matches on the input
      * @throws  PatternSyntaxException
      *          If the expression's syntax is invalid
      */
@@ -1170,9 +1162,9 @@ public final class Pattern
      *
      * <blockquote><table cellpadding=1 cellspacing=0
      *              summary="Split examples showing regex, limit, and result">
-     * <tr><th><P align="left"><i>Regex&nbsp;&nbsp;&nbsp;&nbsp;</i></th>
+     * <tr><th align="left"><i>Regex&nbsp;&nbsp;&nbsp;&nbsp;</i></th>
-     *     <th><P align="left"><i>Limit&nbsp;&nbsp;&nbsp;&nbsp;</i></th>
+     *     <th align="left"><i>Limit&nbsp;&nbsp;&nbsp;&nbsp;</i></th>
-     *     <th><P align="left"><i>Result&nbsp;&nbsp;&nbsp;&nbsp;</i></th></tr>
+     *     <th align="left"><i>Result&nbsp;&nbsp;&nbsp;&nbsp;</i></th></tr>
      * <tr><td align=center>:</td>
      *     <td align=center>2</td>
      *     <td><tt>{ "boo", "and:foo" }</tt></td></tr>
@@ -1253,8 +1245,8 @@ public final class Pattern
      *
      * <blockquote><table cellpadding=1 cellspacing=0
      *              summary="Split examples showing regex and result">
-     * <tr><th><P align="left"><i>Regex&nbsp;&nbsp;&nbsp;&nbsp;</i></th>
+     * <tr><th align="left"><i>Regex&nbsp;&nbsp;&nbsp;&nbsp;</i></th>
-     *     <th><P align="left"><i>Result</i></th></tr>
+     *     <th align="left"><i>Result</i></th></tr>
      * <tr><td align=center>:</td>
      *     <td><tt>{ "boo", "and", "foo" }</tt></td></tr>
      * <tr><td align=center>o</td>

jdk/src/share/classes/java/util/stream/AbstractPipeline.java

@@ -53,11 +53,6 @@ import java.util.function.Supplier;
  * operation, the stream is considered to be consumed, and no more intermediate
  * or terminal operations are permitted on this stream instance.
  *
- * <p>{@code AbstractPipeline} implements a number of methods that are
- * specified in {@link BaseStream}, though it does not implement
- * {@code BaseStream} directly.  Subclasses of {@code AbstractPipeline}
- * will generally implement {@code BaseStream}.
- *
  * @implNote
  * <p>For sequential streams, and parallel streams without
  * <a href="package-summary.html#StreamOps">stateful intermediate
@@ -75,7 +70,7 @@ import java.util.function.Supplier;
  * @since 1.8
  */
 abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
-        extends PipelineHelper<E_OUT> {
+        extends PipelineHelper<E_OUT> implements BaseStream<E_OUT, S> {
     /**
      * Backlink to the head of the pipeline chain (self if this is the source
      * stage).
@@ -286,26 +281,20 @@ abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
 
     // BaseStream
 
-    /**
+    @Override
-     * Implements {@link BaseStream#sequential()}
-     */
     public final S sequential() {
         sourceStage.parallel = false;
         return (S) this;
     }
 
-    /**
+    @Override
-     * Implements {@link BaseStream#parallel()}
-     */
     public final S parallel() {
         sourceStage.parallel = true;
         return (S) this;
     }
 
     // Primitive specialization use co-variant overrides, hence is not final
-    /**
+    @Override
-     * Implements {@link BaseStream#spliterator()}
-     */
     public Spliterator<E_OUT> spliterator() {
         if (linkedOrConsumed)
             throw new IllegalStateException("stream has already been operated upon");
@@ -331,9 +320,7 @@ abstract class AbstractPipeline<E_IN, E_OUT, S extends BaseStream<E_OUT, S>>
         }
     }
 
-    /**
+    @Override
-     * Implements {@link BaseStream#isParallel()}
-     */
     public final boolean isParallel() {
         return sourceStage.parallel;
     }

jdk/src/share/classes/java/util/stream/BaseStream.java

@@ -29,15 +29,13 @@ import java.util.Spliterator;
 
 /**
  * Base interface for stream types such as {@link Stream}, {@link IntStream},
- * etc.  Contains methods common to all stream types.  Many of these methods
+ * etc.  Contains methods common to all stream types.
- * are implemented by {@link AbstractPipeline}, even though
- * {@code AbstractPipeline} does not directly implement {@code BaseStream}.
  *
  * @param <T> type of stream elements
  * @param <S> type of stream implementing {@code BaseStream}
  * @since 1.8
  */
-interface BaseStream<T, S extends BaseStream<T, S>> {
+public interface BaseStream<T, S extends BaseStream<T, S>> {
     /**
      * Returns an iterator for the elements of this stream.
      *

jdk/test/java/lang/SecurityManager/CheckPackageAccess.java

@@ -22,31 +22,133 @@
  */
 
 /*
- * @test
+ *  @test
- * @bug 7146431 8000450
+ *  @bug 6741606 7146431 8000450
- * @summary Test that internal packages cannot be accessed
+ *  @summary Make sure all restricted packages listed in the package.access
+ *           property in the java.security file are blocked
+ *  @run main/othervm CheckPackageAccess
  */
 
+import java.security.Security;
+import java.util.Collections;
+import java.util.Arrays;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.StringTokenizer;
+
+/*
+ * The main benefit of this test is to catch merge errors or other types
+ * of issues where one or more of the packages are accidentally
+ * removed. This is why the packages that are known to be restricted have to
+ * be explicitly listed below.
+ */
 public class CheckPackageAccess {
 
-    public static void main(String[] args) throws Exception {
+    /*
+     * This array should be updated whenever new packages are added to the
+     * package.access property in the java.security file
+     */
+    private static final String[] packages = {
+        "sun.",
+        "com.sun.corba.se.impl.",
+        "com.sun.xml.internal.",
+        "com.sun.imageio.",
+        "com.sun.istack.internal.",
+        "com.sun.jmx.",
+        "com.sun.proxy.",
+        "com.sun.org.apache.bcel.internal.",
+        "com.sun.org.apache.regexp.internal.",
+        "com.sun.org.apache.xerces.internal.",
+        "com.sun.org.apache.xpath.internal.",
+        "com.sun.org.apache.xalan.internal.extensions.",
+        "com.sun.org.apache.xalan.internal.lib.",
+        "com.sun.org.apache.xalan.internal.res.",
+        "com.sun.org.apache.xalan.internal.templates.",
+        "com.sun.org.apache.xalan.internal.utils.",
+        "com.sun.org.apache.xalan.internal.xslt.",
+        "com.sun.org.apache.xalan.internal.xsltc.cmdline.",
+        "com.sun.org.apache.xalan.internal.xsltc.compiler.",
+        "com.sun.org.apache.xalan.internal.xsltc.trax.",
+        "com.sun.org.apache.xalan.internal.xsltc.util.",
+        "com.sun.org.apache.xml.internal.res.",
+        "com.sun.org.apache.xml.internal.security.",
+        "com.sun.org.apache.xml.internal.serializer.utils.",
+        "com.sun.org.apache.xml.internal.utils.",
+        "com.sun.org.glassfish.",
+        "com.oracle.xmlns.internal.",
+        "com.oracle.webservices.internal.",
+        "oracle.jrockit.jfr.",
+        "org.jcp.xml.dsig.internal.",
+        "jdk.internal.",
+        "jdk.nashorn.internal.",
+        "jdk.nashorn.tools."
+    };
 
-        String[] pkgs = new String[] {
+    public static void main(String[] args) throws Exception {
-            "com.sun.corba.se.impl.",
+        List<String> pkgs = new ArrayList<>(Arrays.asList(packages));
-            "com.sun.org.apache.xerces.internal.utils.",
+        String osName = System.getProperty("os.name");
-            "com.sun.org.apache.xalan.internal.utils." };
+        if (osName.contains("OS X")) {
-        SecurityManager sm = new SecurityManager();
+            pkgs.add("apple.");  // add apple package for OS X
-        System.setSecurityManager(sm);
+        } else if (osName.startsWith("Windows")) {
-        for (String pkg : pkgs) {
+            pkgs.add("com.sun.java.accessibility.");
-            System.out.println("Checking package access for " + pkg);
+        }
+
+        List<String> jspkgs =
+            getPackages(Security.getProperty("package.access"));
+
+        // Sort to ensure lists are comparable
+        Collections.sort(pkgs);
+        Collections.sort(jspkgs);
+
+        if (!pkgs.equals(jspkgs)) {
+            for (String p : pkgs)
+                if (!jspkgs.contains(p))
+                    System.out.println("In golden set, but not in j.s file: " + p);
+            for (String p : jspkgs)
+                if (!pkgs.contains(p))
+                    System.out.println("In j.s file, but not in golden set: " + p);
+
+
+            throw new RuntimeException("restricted packages are not " +
+                                       "consistent with java.security file");
+        }
+        System.setSecurityManager(new SecurityManager());
+        SecurityManager sm = System.getSecurityManager();
+        for (String pkg : packages) {
+            String subpkg = pkg + "foo";
             try {
                 sm.checkPackageAccess(pkg);
-                throw new Exception("Expected PackageAccess SecurityException not thrown");
+                throw new RuntimeException("Able to access " + pkg +
+                                           " package");
+            } catch (SecurityException se) { }
+            try {
+                sm.checkPackageAccess(subpkg);
+                throw new RuntimeException("Able to access " + subpkg +
+                                           " package");
             } catch (SecurityException se) { }
             try {
                 sm.checkPackageDefinition(pkg);
-                throw new Exception("Expected PackageDefinition SecurityException not thrown");
+                throw new RuntimeException("Able to define class in " + pkg +
+                                           " package");
+            } catch (SecurityException se) { }
+            try {
+                sm.checkPackageDefinition(subpkg);
+                throw new RuntimeException("Able to define class in " + subpkg +
+                                           " package");
             } catch (SecurityException se) { }
         }
+        System.out.println("Test passed");
+    }
+
+    private static List<String> getPackages(String p) {
+        List<String> packages = new ArrayList<>();
+        if (p != null && !p.equals("")) {
+            StringTokenizer tok = new StringTokenizer(p, ",");
+            while (tok.hasMoreElements()) {
+                String s = tok.nextToken().trim();
+                packages.add(s);
+            }
+        }
+        return packages;
     }
 }