ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/jsr166e/ForkJoinWorkerThread.java
(Generate patch)

Comparing jsr166/src/jsr166e/ForkJoinWorkerThread.java (file contents):
Revision 1.2 by dl, Wed Nov 14 17:20:29 2012 UTC vs.
Revision 1.5 by dl, Wed Jun 19 14:55:40 2013 UTC

# Line 6 | Line 6
6  
7   package jsr166e;
8  
9 +
10   /**
11   * A thread managed by a {@link ForkJoinPool}, which executes
12   * {@link ForkJoinTask}s.
# Line 14 | Line 15 | package jsr166e;
15   * scheduling or execution.  However, you can override initialization
16   * and termination methods surrounding the main task processing loop.
17   * If you do create such a subclass, you will also need to supply a
18 < * custom {@link ForkJoinPool.ForkJoinWorkerThreadFactory} to use it
19 < * in a {@code ForkJoinPool}.
18 > * custom {@link ForkJoinPool.ForkJoinWorkerThreadFactory} to
19 > * {@linkplain ForkJoinPool#ForkJoinPool use it} in a {@code ForkJoinPool}.
20   *
21   * @since 1.7
22   * @author Doug Lea
# Line 25 | Line 26 | public class ForkJoinWorkerThread extend
26       * ForkJoinWorkerThreads are managed by ForkJoinPools and perform
27       * ForkJoinTasks. For explanation, see the internal documentation
28       * of class ForkJoinPool.
29 +     *
30 +     * This class just maintains links to its pool and WorkQueue.  The
31 +     * pool field is set immediately upon construction, but the
32 +     * workQueue field is not set until a call to registerWorker
33 +     * completes. This leads to a visibility race, that is tolerated
34 +     * by requiring that the workQueue field is only accessed by the
35 +     * owning thread.
36       */
37  
30 –    final ForkJoinPool.WorkQueue workQueue; // Work-stealing mechanics
38      final ForkJoinPool pool;                // the pool this thread works in
39 <
33 <    /**
34 <     * An initial name for a newly constructed worker, used until
35 <     * onStart can establish a useful name. This removes need to
36 <     * establish a name from worker startup path.
37 <     */
38 <    static final String provisionalName = "aForkJoinWorkerThread";
39 >    final ForkJoinPool.WorkQueue workQueue; // work-stealing mechanics
40  
41      /**
42       * Creates a ForkJoinWorkerThread operating in the given pool.
# Line 44 | Line 45 | public class ForkJoinWorkerThread extend
45       * @throws NullPointerException if pool is null
46       */
47      protected ForkJoinWorkerThread(ForkJoinPool pool) {
48 <        super(provisionalName); // bootstrap name
49 <        Thread.UncaughtExceptionHandler ueh = pool.ueh;
49 <        if (ueh != null)
50 <            setUncaughtExceptionHandler(ueh);
51 <        setDaemon(true);
48 >        // Use a placeholder until a useful name can be set in registerWorker
49 >        super("aForkJoinWorkerThread");
50          this.pool = pool;
51 <        pool.registerWorker(this.workQueue = new ForkJoinPool.WorkQueue
54 <                            (pool, this, pool.localMode));
51 >        this.workQueue = pool.registerWorker(this);
52      }
53  
54      /**
# Line 64 | Line 61 | public class ForkJoinWorkerThread extend
61      }
62  
63      /**
64 <     * Returns the index number of this thread in its pool.  The
65 <     * returned value ranges from zero to the maximum number of
66 <     * threads (minus one) that have ever been created in the pool.
67 <     * This method may be useful for applications that track status or
68 <     * collect results per-worker rather than per-task.
64 >     * Returns the unique index number of this thread in its pool.
65 >     * The returned value ranges from zero to the maximum number of
66 >     * threads (minus one) that may exist in the pool, and does not
67 >     * change during the lifetime of the thread.  This method may be
68 >     * useful for applications that track status or collect results
69 >     * per-worker-thread rather than per-task.
70       *
71       * @return the index number
72       */
73      public int getPoolIndex() {
74 <        return workQueue.poolIndex;
74 >        return workQueue.poolIndex >>> 1; // ignore odd/even tag bit
75      }
76  
77      /**
# Line 86 | Line 84 | public class ForkJoinWorkerThread extend
84       * processing tasks.
85       */
86      protected void onStart() {
89 –        String pref; // replace bootstrap name
90 –        if (provisionalName.equals(getName()) &&
91 –            (pref = pool.workerNamePrefix) != null)
92 –            setName(pref.concat(Long.toString(getId())));
87      }
88  
89      /**

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines