ViewVC Help

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

root/jsr166/jsr166/src/jsr166e/CompletableFuture.java

Comparing jsr166/src/jsr166e/CompletableFuture.java (file contents):
Revision 1.1 by dl, Wed Jan 2 14:13:12 2013 UTC vs.
Revision 1.5 by jsr166, Thu Jan 3 19:34:31 2013 UTC

#	Line 83 | Line 83 | public class CompletableFuture<T> implem
83		/*
84		* Overview:
85		*
86	<	* 1. Non-nullness of field result (set via CAS) indicates
87	<	* done. An AltResult is used to box null as a result, as well as
88	<	* to hold exceptions.  Using a single field makes completion fast
86	>	* 1. Non-nullness of field result (set via CAS) indicates done.
87	>	* An AltResult is used to box null as a result, as well as to
88	>	* hold exceptions.  Using a single field makes completion fast
89		* and simple to detect and trigger, at the expense of a lot of
90		* encoding and decoding that infiltrates many methods. One minor
91		* simplification relies on the (static) NIL (to box null results)
#	Line 287 | Line 287 | public class CompletableFuture<T> implem
287		else if (q.thread != null && result == null) {
288		try {
289		ForkJoinPool.managedBlock(q);
290	<	} catch(InterruptedException ex){
290	>	} catch (InterruptedException ex) {
291		q.interruptControl = -1;
292		}
293		}
#	Line 320 | Line 320 | public class CompletableFuture<T> implem
320		if (nanos <= 0L)
321		throw new TimeoutException();
322		long d = System.nanoTime() + nanos;
323	<	q = new WaitNode(true, nanos, d == 0L? 1L : d); // avoid 0
323	>	q = new WaitNode(true, nanos, d == 0L ? 1L : d); // avoid 0
324		}
325		else if (!queued)
326		queued = UNSAFE.compareAndSwapObject(this, WAITERS,
#	Line 338 | Line 338 | public class CompletableFuture<T> implem
338		else if (q.thread != null && result == null) {
339		try {
340		ForkJoinPool.managedBlock(q);
341	<	} catch(InterruptedException ex){
341	>	} catch (InterruptedException ex) {
342		q.interruptControl = -1;
343		}
344		}
#	Line 403 | Line 403 | public class CompletableFuture<T> implem
403		}
404		public final boolean exec() {
405		CompletableFuture<Void> d; Throwable ex;
406	<	if ((d = this.dst) != null) {
406	>	if ((d = this.dst) != null && d.result == null) {
407		try {
408		fn.run();
409		ex = null;
#	Line 425 | Line 425 | public class CompletableFuture<T> implem
425		}
426		public final boolean exec() {
427		CompletableFuture<U> d; U u; Throwable ex;
428	<	if ((d = this.dst) != null) {
428	>	if ((d = this.dst) != null && d.result == null) {
429		try {
430		u = fn.get();
431		ex = null;
#	Line 450 | Line 450 | public class CompletableFuture<T> implem
450		}
451		public final boolean exec() {
452		CompletableFuture<U> d; U u; Throwable ex;
453	<	if ((d = this.dst) != null) {
453	>	if ((d = this.dst) != null && d.result == null) {
454		try {
455		u = fn.apply(arg);
456		ex = null;
#	Line 477 | Line 477 | public class CompletableFuture<T> implem
477		}
478		public final boolean exec() {
479		CompletableFuture<V> d; V v; Throwable ex;
480	<	if ((d = this.dst) != null) {
480	>	if ((d = this.dst) != null && d.result == null) {
481		try {
482		v = fn.apply(arg1, arg2);
483		ex = null;
#	Line 502 | Line 502 | public class CompletableFuture<T> implem
502		}
503		public final boolean exec() {
504		CompletableFuture<Void> d; Throwable ex;
505	<	if ((d = this.dst) != null) {
505	>	if ((d = this.dst) != null && d.result == null) {
506		try {
507		fn.accept(arg);
508		ex = null;
#	Line 528 | Line 528 | public class CompletableFuture<T> implem
528		}
529		public final boolean exec() {
530		CompletableFuture<Void> d; Throwable ex;
531	<	if ((d = this.dst) != null) {
531	>	if ((d = this.dst) != null && d.result == null) {
532		try {
533		fn.accept(arg1, arg2);
534		ex = null;
#	Line 2644 | Line 2644 | public class CompletableFuture<T> implem
2644		* completed. This method is designed for use only in error
2645		* recovery actions, and even in such situations may result in
2646		* ongoing dependent completions using established versus
2647	<	* overwritten values.
2647	>	* overwritten outcomes.
2648		*
2649		* @param value the completion value
2650		*/
#	Line 2653 | Line 2653 | public class CompletableFuture<T> implem
2653		postComplete();
2654		}
2655
2656	+	/**
2657	+	* Forcibly causes subsequent invocations of method get() and
2658	+	* related methods to throw the given exception, whether or not
2659	+	* already completed. This method is designed for use only in
2660	+	* recovery actions, and even in such situations may result in
2661	+	* ongoing dependent completions using established versus
2662	+	* overwritten outcomes.
2663	+	*
2664	+	* @param ex the exception
2665	+	*/
2666	+	public void obtrudeException(Throwable ex) {
2667	+	if (ex == null) throw new NullPointerException();
2668	+	result = new AltResult(ex);
2669	+	postComplete();
2670	+	}
2671	+
2672		// Unsafe mechanics
2673		private static final sun.misc.Unsafe UNSAFE;
2674		private static final long RESULT;

Diff Legend

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