ViewVC Help

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

root/jsr166/jsr166/src/jsr166e/ForkJoinTask.java

Comparing jsr166/src/jsr166e/ForkJoinTask.java (file contents):
Revision 1.15 by jsr166, Mon Jul 22 16:52:31 2013 UTC vs.
Revision 1.18 by jsr166, Tue Oct 13 19:45:34 2015 UTC

#	Line 411 | Line 411 | public abstract class ForkJoinTask<V> im
411		final Throwable ex;
412		ExceptionNode next;
413		final long thrower;  // use id not ref to avoid weak cycles
414	+	final int hashCode;  // store task hashCode before weak ref disappears
415		ExceptionNode(ForkJoinTask<?> task, Throwable ex, ExceptionNode next) {
416		super(task, exceptionTableRefQueue);
417		this.ex = ex;
418		this.next = next;
419		this.thrower = Thread.currentThread().getId();
420	+	this.hashCode = System.identityHashCode(task);
421		}
422		}
423
#	Line 574 | Line 576 | public abstract class ForkJoinTask<V> im
576		/**
577		* Poll stale refs and remove them. Call only while holding lock.
578		*/
579	+	/**
580	+	* Poll stale refs and remove them. Call only while holding lock.
581	+	*/
582		private static void expungeStaleExceptions() {
583		for (Object x; (x = exceptionTableRefQueue.poll()) != null;) {
584		if (x instanceof ExceptionNode) {
585	<	ForkJoinTask<?> key = ((ExceptionNode)x).get();
585	>	int hashCode = ((ExceptionNode)x).hashCode;
586		ExceptionNode[] t = exceptionTable;
587	<	int i = System.identityHashCode(key) & (t.length - 1);
587	>	int i = hashCode & (t.length - 1);
588		ExceptionNode e = t[i];
589		ExceptionNode pred = null;
590		while (e != null) {
#	Line 1081 | Line 1086 | public abstract class ForkJoinTask<V> im
1086
1087		/**
1088		* Possibly executes tasks until the pool hosting the current task
1089	<	* {@link ForkJoinPool#isQuiescent is quiescent}. This method may
1090	<	* be of use in designs in which many tasks are forked, but none
1091	<	* are explicitly joined, instead executing them until all are
1092	<	* processed.
1089	>	* {@linkplain ForkJoinPool#isQuiescent is quiescent}.  This
1090	>	* method may be of use in designs in which many tasks are forked,
1091	>	* but none are explicitly joined, instead executing them until
1092	>	* all are processed.
1093		*/
1094		public static void helpQuiesce() {
1095		Thread t;
#	Line 1342 | Line 1347 | public abstract class ForkJoinTask<V> im
1347		}
1348
1349		/**
1350	<	* Adaptor for Runnables. This implements RunnableFuture
1350	>	* Adapter for Runnables. This implements RunnableFuture
1351		* to be compliant with AbstractExecutorService constraints
1352		* when used in ForkJoinPool.
1353		*/
#	Line 1363 | Line 1368 | public abstract class ForkJoinTask<V> im
1368		}
1369
1370		/**
1371	<	* Adaptor for Runnables without results
1371	>	* Adapter for Runnables without results
1372		*/
1373		static final class AdaptedRunnableAction extends ForkJoinTask<Void>
1374		implements RunnableFuture<Void> {
#	Line 1380 | Line 1385 | public abstract class ForkJoinTask<V> im
1385		}
1386
1387		/**
1388	<	* Adaptor for Runnables in which failure forces worker exception
1388	>	* Adapter for Runnables in which failure forces worker exception
1389		*/
1390		static final class RunnableExecuteAction extends ForkJoinTask<Void> {
1391		final Runnable runnable;
#	Line 1398 | Line 1403 | public abstract class ForkJoinTask<V> im
1403		}
1404
1405		/**
1406	<	* Adaptor for Callables
1406	>	* Adapter for Callables
1407		*/
1408		static final class AdaptedCallable<T> extends ForkJoinTask<T>
1409		implements RunnableFuture<T> {

Diff Legend

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