Netty-异步工具类

最新推荐文章于 2024-06-13 08:37:22 发布

Java-峰

最新推荐文章于 2024-06-13 08:37:22 发布

阅读量217

点赞数 3

分类专栏：源码文章标签： java Netty

本文链接：https://blog.csdn.net/fl_zxf/article/details/139129115

版权

源码专栏收录该内容

18 篇文章 0 订阅

订阅专栏

Netty-异步工具类

异步结果

总结：监听器只会通知一次，通知完就会清空监听器

接口

io.netty.util.concurrent.Future

/*** 异步操作结果（扩展的 Future） */
public interface Future<V> extends java.util.concurrent.Future<V> {

    /*** 是否执行（成功）完成 */
    boolean isSuccess();
    /*** 是否可取消 */
    boolean isCancellable();
    /*** 返回执行时的异常 */
    Throwable cause();
    /*** 添加监听器 */
    Future<V> addListener(GenericFutureListener<? extends Future<? super V>> listener);
    /*** 移除监听器 */
    Future<V> removeListener(GenericFutureListener<? extends Future<? super V>> listener);
    /*** 同步等待结果（失败结束时会传递异常抛出） */
    Future<V> sync() throws InterruptedException;
    /*** 同步等待结果（失败结束时会传递异常抛出），并不响应中断 */
    Future<V> syncUninterruptibly();

    ... // 省略其他方法

}

io.netty.util.concurrent.Promise

/*** 可写的特殊 Future */
public interface Promise<V> extends Future<V> {

    /*** 将结果传进去(会校验结果是否设置过，设置过会报错)，设置成功则通知所有监听器 */
    Promise<V> setSuccess(V result);
    /*** 尝试将结果传进去(不校验结果是否设置过，设置过也不会覆盖)，设置成功则通知所有监听器 */
    boolean trySuccess(V result);
    /*** 将异常传进去(会校验结果是否设置过，设置过会报错)，设置成功则通知所有监听器 */
    Promise<V> setFailure(Throwable cause);
    /*** 尝试将异常传进去(不校验结果是否设置过，设置过也不会覆盖)，设置成功则通知所有监听器 */
    boolean tryFailure(Throwable cause);
    /*** 设置为不可取消 */
    boolean setUncancellable();

}

io.netty.channel.ChannelFuture

/*** 异步信道 I/O 操作结果 */
public interface ChannelFuture extends Future<Void> {

    /*** 获取关联的信道 */
    Channel channel();
    /*** 如果是 Void 类型的 Future，返回 true，且相关实例方法不能调用 */
    boolean isVoid();

}

io.netty.channel.ChannelPromise

/*** 可写的特殊 ChannelFuture */
public interface ChannelPromise extends ChannelFuture, Promise<Void> {

    /*** 设置为成功 */
    ChannelPromise setSuccess();
    /*** 尝试设置为成功 */
    boolean trySuccess();
    /*** 如果 isValid() 返回 true，则返回新的 ChannelPromise */
    ChannelPromise unvoid();

}

实现类

DefaultChannelPromise

默认的异步信道 I/O 操作结果实现
类继承关系可参考：基础类介绍-DefaultChannelPromise

// io.netty.channel.DefaultChannelPromise
public class DefaultChannelPromise extends DefaultPromise<Void> implements ChannelPromise, FlushCheckpoint {
    private final Channel channel; // 信道对象
    private long checkpoint;

    /*** 获取执行器 */
    // io.netty.util.concurrent.DefaultPromise #executor
    @Override
    protected EventExecutor executor() {
        EventExecutor e = super.executor();
        if (e == null) {
            return channel().eventLoop(); // 自己没有，则用信道的执行器
        } else {
            return e;
        }
    }

    // io.netty.channel.ChannelPromise #setSuccess()
    @Override
    public ChannelPromise setSuccess() {
        return setSuccess(null); // sign_m_001
    }

    // io.netty.util.concurrent.Promise #setSuccess
    // sign_m_001
    @Override
    public ChannelPromise setSuccess(Void result) {
        super.setSuccess(result); // sign_m_011
        return this;
    }

}

DefaultPromise

默认的 Promise
大部分都使用此类或其子类

// io.netty.util.concurrent.DefaultPromise
public class DefaultPromise<V> extends AbstractFuture<V> implements Promise<V> {
    // 设置成功 sign_m_011
    @Override
    public Promise<V> setSuccess(V result) {
        if (setSuccess0(result)) { // 设为成功
            return this;
        }
        throw new IllegalStateException("complete already: " + this); // 设置过则报错
    }

    // 设为成功
    private boolean setSuccess0(V result) {
        return setValue0(result == null ? SUCCESS : result); // 设置结果值
    }

    // 设置结果值
    private boolean setValue0(Object objResult) {
        if (RESULT_UPDATER.compareAndSet(this, null, objResult) ||
            RESULT_UPDATER.compareAndSet(this, UNCANCELLABLE, objResult)) { // CAS 设置结果成功
            if (checkNotifyWaiters()) { // 检验并通知等待的其他线程
                notifyListeners();      // 通知所有监听器
            }
            return true;
        }
        return false;
    }

    // 检验并通知 wait() 等待的其他线程
    private synchronized boolean checkNotifyWaiters() {
        if (waiters > 0) {
            notifyAll(); // JVM 通知其他线程
        }
        return listener != null || listeners != null;
    }

    // 通知所有监听器
    private void notifyListeners() {
        EventExecutor executor = executor();    // 获取执行器
        if (executor.inEventLoop()) {           // 执行器里面的线程为当前线程
            ...
                    notifyListenersNow();       // 通知
                ...
                return;
            ...
        }

        safeExecute(executor, new Runnable() {  // 使用异步进行通知
            @Override
            public void run() {
                notifyListenersNow();           // 通知
            }
        });
    }

    // 异步执行
    private static void safeExecute(EventExecutor executor, Runnable task) {
        try {
            executor.execute(task);
        } catch (Throwable t) {
            ... // 只是记录日志
        }
    }

    // 通知所有监听器
    private void notifyListenersNow() {
        GenericFutureListener listener;
        DefaultFutureListeners listeners;   // 添加 2 个监听器时，才会创建此集合
        ...         // 省略查找
        for (;;) {  // 循环查找并通知
            if (listener != null) {
                notifyListener0(this, listener);    // 通知单个监听器
            } else {
                notifyListeners0(listeners);        // 通知监听器集合
            }
            synchronized (this) {
                if (this.listener == null && this.listeners == null) {
                    ...
                    return; // 通知过程中没有添加新的监听器，则返回
                }
                listener = this.listener;
                listeners = this.listeners;
                if (listener != null) {
                    this.listener = null;   // 通知完，清空监听器
                } else {
                    this.listeners = null;  // 通知完，清空监听器集合
                }
            }
        }
    }

    /*** 通知监听器集合 */
    private void notifyListeners0(DefaultFutureListeners listeners) {
        GenericFutureListener<?>[] a = listeners.listeners();
        int size = listeners.size();
        for (int i = 0; i < size; i ++) {
            notifyListener0(this, a[i]);    // 通知单个监听器
        }
    }

    /*** 通知单个监听器 */
    private static void notifyListener0(Future future, GenericFutureListener l) {
        try {
            l.operationComplete(future);    // 直接调用
        } catch (Throwable t) {
            ... // 只是记录日志
        }
    }
}

监听器

GenericFutureListener

通用异步结果监听器

// io.netty.util.concurrent.GenericFutureListener
// Future 为 io.netty.util.concurrent.Future 接口
public interface GenericFutureListener<F extends Future<?>> extends EventListener {

    /*** 异步操作完成时被调用 */
    void operationComplete(F future) throws Exception;
    
}