1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
/*
* Copyright (C) 2009 The Guava Authors
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License
* is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
* or implied. See the License for the specific language governing permissions and limitations under
* the License.
*/
package com.google.common.util.concurrent;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.util.concurrent.Uninterruptibles.getUninterruptibly;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicBoolean;
import org.checkerframework.checker.nullness.qual.Nullable;
/**
* Utilities necessary for working with libraries that supply plain {@link Future} instances. Note
* that, whenever possible, it is strongly preferred to modify those libraries to return {@code
* ListenableFuture} directly.
*
* <p>For interoperability between {@code ListenableFuture} and <b>{@code CompletableFuture}</b>,
* consider <a href="https://github.com/lukas-krecan/future-converter">Future Converter</a>.
*
* @author Sven Mawson
* @since 10.0 (replacing {@code Futures.makeListenable}, which existed in 1.0)
*/
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public final class JdkFutureAdapters {
/**
* Assigns a thread to the given {@link Future} to provide {@link ListenableFuture} functionality.
*
* <p><b>Warning:</b> If the input future does not already implement {@code ListenableFuture}, the
* returned future will emulate {@link ListenableFuture#addListener} by taking a thread from an
* internal, unbounded pool at the first call to {@code addListener} and holding it until the
* future is {@linkplain Future#isDone() done}.
*
* <p>Prefer to create {@code ListenableFuture} instances with {@link SettableFuture}, {@link
* MoreExecutors#listeningDecorator( java.util.concurrent.ExecutorService)}, {@link
* ListenableFutureTask}, {@link AbstractFuture}, and other utilities over creating plain {@code
* Future} instances to be upgraded to {@code ListenableFuture} after the fact.
*/
public static <V extends @Nullable Object> ListenableFuture<V> listenInPoolThread(
Future<V> future) {
if (future instanceof ListenableFuture) {
return (ListenableFuture<V>) future;
}
return new ListenableFutureAdapter<>(future);
}
/**
* Submits a blocking task for the given {@link Future} to provide {@link ListenableFuture}
* functionality.
*
* <p><b>Warning:</b> If the input future does not already implement {@code ListenableFuture}, the
* returned future will emulate {@link ListenableFuture#addListener} by submitting a task to the
* given executor at the first call to {@code addListener}. The task must be started by the
* executor promptly, or else the returned {@code ListenableFuture} may fail to work. The task's
* execution consists of blocking until the input future is {@linkplain Future#isDone() done}, so
* each call to this method may claim and hold a thread for an arbitrary length of time. Use of
* bounded executors or other executors that may fail to execute a task promptly may result in
* deadlocks.
*
* <p>Prefer to create {@code ListenableFuture} instances with {@link SettableFuture}, {@link
* MoreExecutors#listeningDecorator( java.util.concurrent.ExecutorService)}, {@link
* ListenableFutureTask}, {@link AbstractFuture}, and other utilities over creating plain {@code
* Future} instances to be upgraded to {@code ListenableFuture} after the fact.
*
* @since 12.0
*/
public static <V extends @Nullable Object> ListenableFuture<V> listenInPoolThread(
Future<V> future, Executor executor) {
checkNotNull(executor);
if (future instanceof ListenableFuture) {
return (ListenableFuture<V>) future;
}
return new ListenableFutureAdapter<>(future, executor);
}
/**
* An adapter to turn a {@link Future} into a {@link ListenableFuture}. This will wait on the
* future to finish, and when it completes, run the listeners. This implementation will wait on
* the source future indefinitely, so if the source future never completes, the adapter will never
* complete either.
*
* <p>If the delegate future is interrupted or throws an unexpected unchecked exception, the
* listeners will not be invoked.
*/
private static class ListenableFutureAdapter<V extends @Nullable Object>
extends ForwardingFuture<V> implements ListenableFuture<V> {
private static final ThreadFactory threadFactory =
new ThreadFactoryBuilder()
.setDaemon(true)
.setNameFormat("ListenableFutureAdapter-thread-%d")
.build();
private static final Executor defaultAdapterExecutor =
Executors.newCachedThreadPool(threadFactory);
private final Executor adapterExecutor;
// The execution list to hold our listeners.
private final ExecutionList executionList = new ExecutionList();
// This allows us to only start up a thread waiting on the delegate future when the first
// listener is added.
private final AtomicBoolean hasListeners = new AtomicBoolean(false);
// The delegate future.
private final Future<V> delegate;
ListenableFutureAdapter(Future<V> delegate) {
this(delegate, defaultAdapterExecutor);
}
ListenableFutureAdapter(Future<V> delegate, Executor adapterExecutor) {
this.delegate = checkNotNull(delegate);
this.adapterExecutor = checkNotNull(adapterExecutor);
}
@Override
protected Future<V> delegate() {
return delegate;
}
@Override
public void addListener(Runnable listener, Executor exec) {
executionList.add(listener, exec);
// When a listener is first added, we run a task that will wait for the delegate to finish,
// and when it is done will run the listeners.
if (hasListeners.compareAndSet(false, true)) {
if (delegate.isDone()) {
// If the delegate is already done, run the execution list immediately on the current
// thread.
executionList.execute();
return;
}
// TODO(lukes): handle RejectedExecutionException
adapterExecutor.execute(
() -> {
try {
/*
* Threads from our private pool are never interrupted. Threads from a
* user-supplied executor might be, but... what can we do? This is another reason
* to return a proper ListenableFuture instead of using listenInPoolThread.
*/
getUninterruptibly(delegate);
} catch (Throwable t) {
// (including CancellationException and sneaky checked exception)
// The task is presumably done, run the listeners.
// TODO(cpovirk): Do *something* in case of Error (and maybe
// non-CancellationException, non-ExecutionException exceptions)?
}
executionList.execute();
});
}
}
}
private JdkFutureAdapters() {}
}
|
