ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/main/java/util/concurrent/ForkJoinPool.java
(Generate patch)

Comparing jsr166/src/main/java/util/concurrent/ForkJoinPool.java (file contents):
Revision 1.6 by jsr166, Thu Jul 30 04:19:41 2009 UTC vs.
Revision 1.7 by jsr166, Fri Jul 31 20:41:13 2009 UTC

# Line 587 | Line 587 | public class ForkJoinPool extends Abstra
587          if (task instanceof ForkJoinTask<?>) // avoid re-wrap
588              job = (ForkJoinTask<?>) task;
589          else
590 <            job = new AdaptedRunnable<Void>(task, null);
590 >            job = ForkJoinTask.adapt(task, null);
591          doSubmit(job);
592      }
593  
594      public <T> ForkJoinTask<T> submit(Callable<T> task) {
595 <        ForkJoinTask<T> job = new AdaptedCallable<T>(task);
595 >        ForkJoinTask<T> job = ForkJoinTask.adapt(task);
596          doSubmit(job);
597          return job;
598      }
599  
600      public <T> ForkJoinTask<T> submit(Runnable task, T result) {
601 <        ForkJoinTask<T> job = new AdaptedRunnable<T>(task, result);
601 >        ForkJoinTask<T> job = ForkJoinTask.adapt(task, result);
602          doSubmit(job);
603          return job;
604      }
# Line 608 | Line 608 | public class ForkJoinPool extends Abstra
608          if (task instanceof ForkJoinTask<?>) // avoid re-wrap
609              job = (ForkJoinTask<?>) task;
610          else
611 <            job = new AdaptedRunnable<Void>(task, null);
611 >            job = ForkJoinTask.adapt(task, null);
612          doSubmit(job);
613          return job;
614      }
# Line 627 | Line 627 | public class ForkJoinPool extends Abstra
627          return task;
628      }
629  
630 –    /**
631 –     * Adaptor for Runnables. This implements RunnableFuture
632 –     * to be compliant with AbstractExecutorService constraints.
633 –     */
634 –    static final class AdaptedRunnable<T> extends ForkJoinTask<T>
635 –        implements RunnableFuture<T> {
636 –        final Runnable runnable;
637 –        final T resultOnCompletion;
638 –        T result;
639 –        AdaptedRunnable(Runnable runnable, T result) {
640 –            if (runnable == null) throw new NullPointerException();
641 –            this.runnable = runnable;
642 –            this.resultOnCompletion = result;
643 –        }
644 –        public T getRawResult() { return result; }
645 –        public void setRawResult(T v) { result = v; }
646 –        public boolean exec() {
647 –            runnable.run();
648 –            result = resultOnCompletion;
649 –            return true;
650 –        }
651 –        public void run() { invoke(); }
652 –        private static final long serialVersionUID = 5232453952276885070L;
653 –    }
654 –
655 –    /**
656 –     * Adaptor for Callables
657 –     */
658 –    static final class AdaptedCallable<T> extends ForkJoinTask<T>
659 –        implements RunnableFuture<T> {
660 –        final Callable<T> callable;
661 –        T result;
662 –        AdaptedCallable(Callable<T> callable) {
663 –            if (callable == null) throw new NullPointerException();
664 –            this.callable = callable;
665 –        }
666 –        public T getRawResult() { return result; }
667 –        public void setRawResult(T v) { result = v; }
668 –        public boolean exec() {
669 –            try {
670 –                result = callable.call();
671 –                return true;
672 –            } catch (Error err) {
673 –                throw err;
674 –            } catch (RuntimeException rex) {
675 –                throw rex;
676 –            } catch (Exception ex) {
677 –                throw new RuntimeException(ex);
678 –            }
679 –        }
680 –        public void run() { invoke(); }
681 –        private static final long serialVersionUID = 2838392045355241008L;
682 –    }
630  
631      public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) {
632          ArrayList<ForkJoinTask<T>> forkJoinTasks =
633              new ArrayList<ForkJoinTask<T>>(tasks.size());
634          for (Callable<T> task : tasks)
635 <            forkJoinTasks.add(new AdaptedCallable<T>(task));
635 >            forkJoinTasks.add(ForkJoinTask.adapt(task));
636          invoke(new InvokeAll<T>(forkJoinTasks));
637  
638          @SuppressWarnings({"unchecked", "rawtypes"})
# Line 1130 | Line 1077 | public class ForkJoinPool extends Abstra
1077                          transitionRunStateTo(TERMINATED);
1078                          termination.signalAll();
1079                      }
1133 –                    
1080                  } finally {
1081                      lock.unlock();
1082                  }
# Line 1880 | Line 1826 | public class ForkJoinPool extends Abstra
1826          do {} while (!blocker.isReleasable() && !blocker.block());
1827      }
1828  
1829 <    // AbstractExecutorService overrides
1829 >    // AbstractExecutorService overrides.  These rely on undocumented
1830 >    // fact that ForkJoinTask.adapt returns ForkJoinTasks that also
1831 >    // implement RunnableFuture.
1832  
1833      protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
1834 <        return new AdaptedRunnable<T>(runnable, value);
1834 >        return (RunnableFuture<T>) ForkJoinTask.adapt(runnable, value);
1835      }
1836  
1837      protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
1838 <        return new AdaptedCallable<T>(callable);
1838 >        return (RunnableFuture<T>) ForkJoinTask.adapt(callable);
1839      }
1840  
1841      // Unsafe mechanics

Diff Legend

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