83 |
|
* subdivided) to each element of an array or collection; especially |
84 |
|
* when the operation takes a significantly different amount of time |
85 |
|
* to complete for some elements than others, either because of |
86 |
< |
* intrinsic variation (for example IO) or auxiliary effects such as |
86 |
> |
* intrinsic variation (for example I/O) or auxiliary effects such as |
87 |
|
* garbage collection. Because CountedCompleters provide their own |
88 |
|
* continuations, other threads need not block waiting to perform |
89 |
|
* them. |
126 |
|
* op.apply(array[lo]); |
127 |
|
* tryComplete(); |
128 |
|
* } |
129 |
< |
* } }</pre> |
129 |
> |
* }}</pre> |
130 |
|
* |
131 |
|
* This design can be improved by noticing that in the recursive case, |
132 |
|
* the task has nothing to do after forking its right task, so can |
133 |
|
* directly invoke its left task before returning. (This is an analog |
134 |
|
* of tail recursion removal.) Also, because the task returns upon |
135 |
|
* executing its left task (rather than falling through to invoke |
136 |
< |
* tryComplete) the pending count is set to one: |
136 |
> |
* {@code tryComplete}) the pending count is set to one: |
137 |
|
* |
138 |
|
* <pre> {@code |
139 |
|
* class ForEach<E> ... |
183 |
|
* |
184 |
|
* <p><b>Searching.</b> A tree of CountedCompleters can search for a |
185 |
|
* value or property in different parts of a data structure, and |
186 |
< |
* report a result in an {@link java.util.concurrent.AtomicReference} |
187 |
< |
* as soon as one is found. The others can poll the result to avoid |
188 |
< |
* unnecessary work. (You could additionally {@link #cancel} other |
189 |
< |
* tasks, but it is usually simpler and more efficient to just let |
190 |
< |
* them notice that the result is set and if so skip further |
191 |
< |
* processing.) Illustrating again with an array using full |
186 |
> |
* report a result in an {@link |
187 |
> |
* java.util.concurrent.atomic.AtomicReference AtomicReference} as |
188 |
> |
* soon as one is found. The others can poll the result to avoid |
189 |
> |
* unnecessary work. (You could additionally {@linkplain #cancel |
190 |
> |
* cancel} other tasks, but it is usually simpler and more efficient |
191 |
> |
* to just let them notice that the result is set and if so skip |
192 |
> |
* further processing.) Illustrating again with an array using full |
193 |
|
* partitioning (again, in practice, leaf tasks will almost always |
194 |
|
* process more than one element): |
195 |
|
* |
224 |
|
* public static <E> E search(E[] array) { |
225 |
|
* return new Searcher<E>(null, array, new AtomicReference<E>(), 0, array.length).invoke(); |
226 |
|
* } |
227 |
< |
*}}</pre> |
227 |
> |
* }}</pre> |
228 |
|
* |
229 |
|
* In this example, as well as others in which tasks have no other |
230 |
|
* effects except to compareAndSet a common result, the trailing |
278 |
|
* } |
279 |
|
* public void onCompletion(CountedCompleter<?> caller) { |
280 |
|
* if (caller != this) { |
281 |
< |
* MapReducer<E> child = (MapReducer<E>)caller; |
282 |
< |
* MapReducer<E> sib = child.sibling; |
283 |
< |
* if (sib == null || sib.result == null) |
284 |
< |
* result = child.result; |
285 |
< |
* else |
286 |
< |
* result = reducer.apply(child.result, sib.result); |
281 |
> |
* MapReducer<E> child = (MapReducer<E>)caller; |
282 |
> |
* MapReducer<E> sib = child.sibling; |
283 |
> |
* if (sib == null || sib.result == null) |
284 |
> |
* result = child.result; |
285 |
> |
* else |
286 |
> |
* result = reducer.apply(child.result, sib.result); |
287 |
|
* } |
288 |
|
* } |
289 |
|
* public E getRawResult() { return result; } |
292 |
|
* return new MapReducer<E>(null, array, mapper, reducer, |
293 |
|
* 0, array.length).invoke(); |
294 |
|
* } |
295 |
< |
* } }</pre> |
295 |
> |
* }}</pre> |
296 |
|
* |
297 |
|
* Here, method {@code onCompletion} takes a form common to many |
298 |
|
* completion designs that combine results. This callback-style method |
389 |
|
* Creates a new CountedCompleter with the given completer |
390 |
|
* and initial pending count. |
391 |
|
* |
392 |
< |
* @param completer this tasks completer, or {@code null} if none |
392 |
> |
* @param completer this task's completer, or {@code null} if none |
393 |
|
* @param initialPendingCount the initial pending count |
394 |
|
*/ |
395 |
|
protected CountedCompleter(CountedCompleter<?> completer, |
402 |
|
* Creates a new CountedCompleter with the given completer |
403 |
|
* and an initial pending count of zero. |
404 |
|
* |
405 |
< |
* @param completer this tasks completer, or {@code null} if none |
405 |
> |
* @param completer this task's completer, or {@code null} if none |
406 |
|
*/ |
407 |
|
protected CountedCompleter(CountedCompleter<?> completer) { |
408 |
|
this.completer = completer; |
423 |
|
|
424 |
|
/** |
425 |
|
* Performs an action when method {@link #tryComplete} is invoked |
426 |
< |
* and there are no pending counts, or when the unconditional |
426 |
> |
* and the pending count is zero, or when the unconditional |
427 |
|
* method {@link #complete} is invoked. By default, this method |
428 |
|
* does nothing. You can distinguish cases by checking the |
429 |
|
* identity of the given caller argument. If not equal to {@code |
451 |
|
* @param caller the task invoking this method (which may |
452 |
|
* be this task itself). |
453 |
|
* @return true if this exception should be propagated to this |
454 |
< |
* tasks completer, if one exists. |
454 |
> |
* task's completer, if one exists. |
455 |
|
*/ |
456 |
|
public boolean onExceptionalCompletion(Throwable ex, CountedCompleter<?> caller) { |
457 |
|
return true; |
662 |
|
} |
663 |
|
|
664 |
|
/** |
665 |
< |
* Support for FJT exception propagation |
665 |
> |
* Supports ForkJoinTask exception propagation. |
666 |
|
*/ |
667 |
|
void internalPropagateException(Throwable ex) { |
668 |
|
CountedCompleter<?> a = this, s = a; |
672 |
|
} |
673 |
|
|
674 |
|
/** |
675 |
< |
* Implements execution conventions for CountedCompleters |
675 |
> |
* Implements execution conventions for CountedCompleters. |
676 |
|
*/ |
677 |
|
protected final boolean exec() { |
678 |
|
compute(); |