| 247 |
|
synchronized (this) { |
| 248 |
|
try { |
| 249 |
|
while (status >= 0) { |
| 250 |
< |
long nt = nanos - System.nanoTime() - startTime; |
| 250 |
> |
long nt = nanos - (System.nanoTime() - startTime); |
| 251 |
|
if (nt <= 0) |
| 252 |
|
break; |
| 253 |
|
wait(nt / 1000000, (int) (nt % 1000000)); |
| 777 |
|
|
| 778 |
|
public final V get(long timeout, TimeUnit unit) |
| 779 |
|
throws InterruptedException, ExecutionException, TimeoutException { |
| 780 |
+ |
long nanos = unit.toNanos(timeout); |
| 781 |
|
ForkJoinWorkerThread w = getWorker(); |
| 782 |
|
if (w == null || status < 0 || !w.unpushTask(this) || !tryQuietlyInvoke()) |
| 783 |
< |
awaitDone(w, unit.toNanos(timeout)); |
| 783 |
> |
awaitDone(w, nanos); |
| 784 |
|
return reportTimedFutureResult(); |
| 785 |
|
} |
| 786 |
|
|
| 984 |
|
protected abstract boolean exec(); |
| 985 |
|
|
| 986 |
|
/** |
| 987 |
< |
* Returns, but does not unschedule or execute, the task queued by |
| 988 |
< |
* the current thread but not yet executed, if one is |
| 987 |
> |
* Returns, but does not unschedule or execute, a task queued by |
| 988 |
> |
* the current thread but not yet executed, if one is immediately |
| 989 |
|
* available. There is no guarantee that this task will actually |
| 990 |
< |
* be polled or executed next. This method is designed primarily |
| 991 |
< |
* to support extensions, and is unlikely to be useful otherwise. |
| 992 |
< |
* This method may be invoked only from within ForkJoinTask |
| 993 |
< |
* computations (as may be determined using method {@link |
| 994 |
< |
* #inForkJoinPool}). Attempts to invoke in other contexts result |
| 995 |
< |
* in exceptions or errors, possibly including ClassCastException. |
| 990 |
> |
* be polled or executed next. Conversely, this method may return |
| 991 |
> |
* null even if a task exists but cannot be accessed without |
| 992 |
> |
* contention with other threads. This method is designed |
| 993 |
> |
* primarily to support extensions, and is unlikely to be useful |
| 994 |
> |
* otherwise. This method may be invoked only from within |
| 995 |
> |
* ForkJoinTask computations (as may be determined using method |
| 996 |
> |
* {@link #inForkJoinPool}). Attempts to invoke in other contexts |
| 997 |
> |
* result in exceptions or errors, possibly including |
| 998 |
> |
* ClassCastException. |
| 999 |
|
* |
| 1000 |
|
* @return the next task, or {@code null} if none are available |
| 1001 |
|
*/ |
| 1042 |
|
.pollTask(); |
| 1043 |
|
} |
| 1044 |
|
|
| 1045 |
< |
// adaptors |
| 1045 |
> |
/** |
| 1046 |
> |
* Adaptor for Runnables. This implements RunnableFuture |
| 1047 |
> |
* to be compliant with AbstractExecutorService constraints |
| 1048 |
> |
* when used in ForkJoinPool. |
| 1049 |
> |
*/ |
| 1050 |
> |
static final class AdaptedRunnable<T> extends ForkJoinTask<T> |
| 1051 |
> |
implements RunnableFuture<T> { |
| 1052 |
> |
final Runnable runnable; |
| 1053 |
> |
final T resultOnCompletion; |
| 1054 |
> |
T result; |
| 1055 |
> |
AdaptedRunnable(Runnable runnable, T result) { |
| 1056 |
> |
if (runnable == null) throw new NullPointerException(); |
| 1057 |
> |
this.runnable = runnable; |
| 1058 |
> |
this.resultOnCompletion = result; |
| 1059 |
> |
} |
| 1060 |
> |
public T getRawResult() { return result; } |
| 1061 |
> |
public void setRawResult(T v) { result = v; } |
| 1062 |
> |
public boolean exec() { |
| 1063 |
> |
runnable.run(); |
| 1064 |
> |
result = resultOnCompletion; |
| 1065 |
> |
return true; |
| 1066 |
> |
} |
| 1067 |
> |
public void run() { invoke(); } |
| 1068 |
> |
private static final long serialVersionUID = 5232453952276885070L; |
| 1069 |
> |
} |
| 1070 |
> |
|
| 1071 |
> |
/** |
| 1072 |
> |
* Adaptor for Callables |
| 1073 |
> |
*/ |
| 1074 |
> |
static final class AdaptedCallable<T> extends ForkJoinTask<T> |
| 1075 |
> |
implements RunnableFuture<T> { |
| 1076 |
> |
final Callable<T> callable; |
| 1077 |
> |
T result; |
| 1078 |
> |
AdaptedCallable(Callable<T> callable) { |
| 1079 |
> |
if (callable == null) throw new NullPointerException(); |
| 1080 |
> |
this.callable = callable; |
| 1081 |
> |
} |
| 1082 |
> |
public T getRawResult() { return result; } |
| 1083 |
> |
public void setRawResult(T v) { result = v; } |
| 1084 |
> |
public boolean exec() { |
| 1085 |
> |
try { |
| 1086 |
> |
result = callable.call(); |
| 1087 |
> |
return true; |
| 1088 |
> |
} catch (Error err) { |
| 1089 |
> |
throw err; |
| 1090 |
> |
} catch (RuntimeException rex) { |
| 1091 |
> |
throw rex; |
| 1092 |
> |
} catch (Exception ex) { |
| 1093 |
> |
throw new RuntimeException(ex); |
| 1094 |
> |
} |
| 1095 |
> |
} |
| 1096 |
> |
public void run() { invoke(); } |
| 1097 |
> |
private static final long serialVersionUID = 2838392045355241008L; |
| 1098 |
> |
} |
| 1099 |
|
|
| 1100 |
|
/** |
| 1101 |
|
* Returns a new ForkJoinTask that performs the {@code run} |
| 1106 |
|
* @return the task |
| 1107 |
|
*/ |
| 1108 |
|
public static ForkJoinTask<Void> adapt(Runnable runnable) { |
| 1109 |
< |
return new ForkJoinPool.AdaptedRunnable<Void>(runnable, null); |
| 1109 |
> |
return new AdaptedRunnable<Void>(runnable, null); |
| 1110 |
|
} |
| 1111 |
|
|
| 1112 |
|
/** |
| 1119 |
|
* @return the task |
| 1120 |
|
*/ |
| 1121 |
|
public static <T> ForkJoinTask<T> adapt(Runnable runnable, T result) { |
| 1122 |
< |
return new ForkJoinPool.AdaptedRunnable<T>(runnable, result); |
| 1122 |
> |
return new AdaptedRunnable<T>(runnable, result); |
| 1123 |
|
} |
| 1124 |
|
|
| 1125 |
|
/** |
| 1132 |
|
* @return the task |
| 1133 |
|
*/ |
| 1134 |
|
public static <T> ForkJoinTask<T> adapt(Callable<T> callable) { |
| 1135 |
< |
return new ForkJoinPool.AdaptedCallable<T>(callable); |
| 1135 |
> |
return new AdaptedCallable<T>(callable); |
| 1136 |
|
} |
| 1137 |
|
|
| 1138 |
|
// Serialization support |
