ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/jsr166y/ForkJoinTask.java

Comparing jsr166/src/jsr166y/ForkJoinTask.java (file contents):
Revision 1.60 by jsr166, Tue Sep 7 23:17:10 2010 UTC vs.
Revision 1.62 by dl, Fri Sep 17 14:24:56 2010 UTC

#	Line 28 | Line 28 | import java.util.WeakHashMap;
28		* start other subtasks.  As indicated by the name of this class,
29		* many programs using {@code ForkJoinTask} employ only methods
30		* {@link #fork} and {@link #join}, or derivatives such as {@link
31	<	* #invokeAll}.  However, this class also provides a number of other
32	<	* methods that can come into play in advanced usages, as well as
33	<	* extension mechanics that allow support of new forms of fork/join
34	<	* processing.
31	>	* #invokeAll(ForkJoinTask...) invokeAll}.  However, this class also
32	>	* provides a number of other methods that can come into play in
33	>	* advanced usages, as well as extension mechanics that allow
34	>	* support of new forms of fork/join processing.
35		*
36		* <p>A {@code ForkJoinTask} is a lightweight form of {@link Future}.
37		* The efficiency of {@code ForkJoinTask}s stems from a set of
#	Line 223 | Line 223 | public abstract class ForkJoinTask<V> im
223		int s;         // the odd construction reduces lock bias effects
224		while ((s = status) >= 0) {
225		try {
226	<	synchronized(this) {
226	>	synchronized (this) {
227		if (UNSAFE.compareAndSwapInt(this, statusOffset, s,SIGNAL))
228		wait();
229		}
#	Line 243 | Line 243 | public abstract class ForkJoinTask<V> im
243		int s;
244		if ((s = status) >= 0) {
245		try {
246	<	synchronized(this) {
246	>	synchronized (this) {
247		if (UNSAFE.compareAndSwapInt(this, statusOffset, s,SIGNAL))
248		wait(millis, 0);
249		}
#	Line 261 | Line 261 | public abstract class ForkJoinTask<V> im
261		private void externalAwaitDone() {
262		int s;
263		while ((s = status) >= 0) {
264	<	synchronized(this) {
264	>	synchronized (this) {
265		if (UNSAFE.compareAndSwapInt(this, statusOffset, s, SIGNAL)){
266		boolean interrupted = false;
267		while (status >= 0) {
#	Line 642 | Line 642 | public abstract class ForkJoinTask<V> im
642		setCompletion(NORMAL);
643		}
644
645	+	/**
646	+	* @throws CancellationException {@inheritDoc}
647	+	*/
648		public final V get() throws InterruptedException, ExecutionException {
649	<	quietlyJoin();
650	<	if (Thread.interrupted())
651	<	throw new InterruptedException();
652	<	int s = status;
649	>	int s;
650	>	if (Thread.currentThread() instanceof ForkJoinWorkerThread) {
651	>	quietlyJoin();
652	>	s = status;
653	>	}
654	>	else {
655	>	while ((s = status) >= 0) {
656	>	synchronized (this) { // interruptible form of awaitDone
657	>	if (UNSAFE.compareAndSwapInt(this, statusOffset,
658	>	s, SIGNAL)) {
659	>	while (status >= 0)
660	>	wait();
661	>	}
662	>	}
663	>	}
664	>	}
665		if (s < NORMAL) {
666		Throwable ex;
667		if (s == CANCELLED)
#	Line 657 | Line 672 | public abstract class ForkJoinTask<V> im
672		return getRawResult();
673		}
674
675	+	/**
676	+	* @throws CancellationException {@inheritDoc}
677	+	*/
678		public final V get(long timeout, TimeUnit unit)
679		throws InterruptedException, ExecutionException, TimeoutException {
680		Thread t = Thread.currentThread();
#	Line 698 | Line 716 | public abstract class ForkJoinTask<V> im
716		long ms = nt / 1000000;
717		int ns = (int) (nt % 1000000);
718		try {
719	<	synchronized(this) {
719	>	synchronized (this) {
720		if (status >= 0)
721		wait(ms, ns);
722		}

Diff Legend

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