Future和Promise组件

  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

/**
 * A {@link Future} which allows to register {@link GenericFutureListener}s which will receive notifications
 * once the {@link Future} is done or failed.
 */
public interface Future<V> extends java.util.concurrent.Future<V>, ChannelFuture {

    // 添加一个监听器，用于接收操作完成或失败的通知
    Future<V> addListener(GenericFutureListener<? extends Future<? super V>> listener);

    // 添加一个监听器，用于接收操作完成或失败的通知，并返回一个新的 Future
    Future<V> addListener(GenericFutureListener<? extends Future<? super V>> listener, EventExecutor executor);

    // 移除一个监听器
    Future<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener);

    // 移除一个监听器
    Future<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener, EventExecutor executor);

    // 设置操作结果，并通知所有监听器
    boolean setSuccess(V result);

    // 设置操作失败，并通知所有监听器
    boolean setFailure(Throwable cause);

    // 判断操作是否成功完成
    boolean isSuccess();

    // 判断操作是否失败
    boolean isFailed();

    // 获取操作结果
    V getNow();

    // 等待操作完成，并返回操作结果
    V get() throws InterruptedException, ExecutionException;

    // 等待操作完成，并返回操作结果，超时时间为 timeoutMillis 毫秒
    V get(long timeoutMillis) throws InterruptedException, ExecutionException, TimeoutException;

    // 判断操作是否被取消
    boolean isCancelled();

    // 取消操作
    boolean cancel(boolean mayInterruptIfRunning);

    // 添加一个操作完成后的回调函数
    Future<V> sync();

    // 添加一个操作完成后的回调函数，超时时间为 timeoutMillis 毫秒
    Future<V> syncUninterruptibly();

    // 添加一个操作完成后的回调函数，超时时间为 timeoutMillis 毫秒
    Future<V> syncUninterruptibly(long timeoutMillis);

    // 添加一个操作完成后的回调函数，并返回一个新的 Future
    Future<V> await() throws InterruptedException;

    // 添加一个操作完成后的回调函数，超时时间为 timeoutMillis 毫秒，并返回一个新的 Future
    Future<V> await(long timeoutMillis) throws InterruptedException;

    // 添加一个操作完成后的回调函数，并返回一个新的 Future
    Future<V> awaitUninterruptibly();

    // 添加一个操作完成后的回调函数，超时时间为 timeoutMillis 毫秒，并返回一个新的 Future
    Future<V> awaitUninterruptibly(long timeoutMillis);

    // 返回一个新的 Future，它的操作结果是当前 Future 和另一个 Future 的组合结果
    <C> Future<C> combine(Future<? extends C> other, BiFunction<? super V, ? super C, ? extends C> fn);

    // 返回一个新的 Future，它的操作结果是当前 Future 和另一个 Future 的组合结果，超时时间为 timeoutMillis 毫秒
    <C> Future<C> combine(Future<? extends C> other, BiFunction<? super V, ? super C, ? extends C> fn, long timeoutMillis);

    // 返回一个新的 Future，它的操作结果是当前 Future 和另一个 Future 的组合结果，超时时间为 timeoutMillis 毫秒，并在另一个 Future 完成前不会执行组合操作
    <C> Future<C> compose(Future<? extends C> other, BiFunction<? super V, ? super C, ? extends C> fn, long timeoutMillis);

    // 返回一个新的 Future，它的操作结果是当前 Future 和另一个 Future 的组合结果，超时时间为 timeoutMillis 毫秒，并在另一个 Future 完成前不会执行组合操作
    <C> Future<C> compose(Future<? extends C> other, BiFunction<? super V, ? super C, ? extends C> fn);
}

/**
 * A {@link Future} which allows to set its success or failure.
 */
public interface Promise<V> extends Future<V> {

    // 设置操作结果，并通知所有监听器
    Promise<V> setSuccess(V result);

    // 设置操作失败，并通知所有监听器
    Promise<V> setFailure(Throwable cause);

    // 判断操作是否已经完成
    boolean isDone();

    // 添加一个监听器，用于接收操作完成或失败的通知
    Promise<V> addListener(GenericFutureListener<? extends Future<? super V>> listener);

    // 添加一个监听器，用于接收操作完成或失败的通知，并返回一个新的 Promise
    Promise<V> addListener(GenericFutureListener<? extends Future<? super V>> listener, EventExecutor executor);

    // 移除一个监听器
    Promise<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener);

    // 移除一个监听器
    Promise<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener, EventExecutor executor);

    // 设置操作结果，并通知所有监听器
    boolean trySuccess(V result);

    // 设置操作失败，并通知所有监听器
    boolean tryFailure(Throwable cause);

    // 判断操作是否已经被取消
    boolean isCancellable();

    // 取消操作
    Promise<V> cancel(boolean mayInterruptIfRunning);

    // 判断操作是否已经被取消
    boolean isCancelled();

    // 添加一个操作完成后的回调函数
    Promise<V> sync();

    // 添加一个操作完成后的回调函数，超时时间为 timeoutMillis 毫秒
    Promise<V> syncUninterruptibly();

    // 添加一个操作完成后的回调函数，超时时间为 timeoutMillis 毫秒
    Promise<V> syncUninterruptibly(long timeoutMillis);

    // 添加一个操作完成后的回调函数，并返回一个新的 Promise
    Promise<V> await() throws InterruptedException;

    // 添加一个操作完成后的回调函数，超时时间为 timeoutMillis 毫秒，并返回一个新的 Promise
    Promise<V> await(long timeoutMillis) throws InterruptedException;

    // 添加一个操作完成后的回调函数，并返回一个新的 Promise
    Promise<V> awaitUninterruptibly();

    // 添加一个操作完成后的回调函数，超时时间为 timeoutMillis 毫秒，并返回一个新的 Promise
    Promise<V> awaitUninterruptibly(long timeoutMillis);
}