【自己读源码】Netty4.X系列(四) Netty中的异步调用

Netty中的异步调用

如果大家观察仔细,会发现我们之前所写的代码都是串行执行的,这是什么意思?就是我们看到代码是什么顺序,最后程序就是按什么顺序执行的。

但是Netty作为一个高性能网络框架,他的调用很多都是异步的,这样,就可以不等上一步做完,继续行进下一步,达到多任务并行的作用。

实现概述

Netty是怎么实现他的异步调用呢,大致总结了下由以下几个核心部分
组成:

  • 异步执行(executor)
  • 异步结果(future and promise)
  • Listener
  • 同步接口

首先,既然是异步调用,肯定要有异步执行,同学们这里肯定想到的是使用线程,没错,他的底层确实也是线程,只不过netty自身封装成了executor,增强了线程的调度。

其次,是要能获取到这次执行的结果,有的同学可能会说使用callable,没错这确实是一种解决方案,但是netty并没有使用这种,而是使用了一种更为巧妙的设计(也就是通过promise对象来传递执行的结果)来完成这种操作,下面我们会详细说明。

最后就是promise对象提供的各种接口,比如Listener:可以监听执行的完成。或者是同步接口:保证异步执行的方法顺序也是同步的。这篇文章中,我们主要就讲这两,三个,其他的各位童鞋可以自己去看源码。

Executor实现

Netty中每个Channel都有一个eventloop对象,实现还蛮复杂的,在这里不是重点,所以我们先实现一个,具有异步调用功能的exector。

自定义executor很简单,只要实现Executor接口就行

public class MyNettyExecutor implements Executor {
private ThreadFactory factory;

public MyNettyExecutor(ThreadFactory factory) {
    this.factory = factory;
}

public void execute(Runnable command) {
    factory.newThread(command).start();
}
}

然后在需要使用的时候,实例化这个类,这里为了增强使用,我们在类内部提供一个静态初始化方法,并提供最简单factory实现。

 public static Executor newExecutor(){
        return new MyNettyExecutor(new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                return new Thread(r);
            }
        });
    }

Promise详解

对furture/promise的理解

我对future的认识最开始源于Java的FutureTask框架,简单来说,FutureTask是Future接口的一种实现,Future则是异步执行的结果。
而promise,从接口注释上来看,是一种可修改的Future

/**
 * Special {@link Future} which is writable.
 */

那么现在来看,一个异步结果的程序主要有下面几步

  1. 生成promise对象
  2. 具体调用的地方传入promise参数
  3. 异步调用完成后,设置promise为完成
  4. 返回future对象

其中,第三步是发生在异步调用里的,所以我们看到的顺序其实就是1->2>4,让我们来画一张图。
【自己读源码】Netty4.X系列(四) Netty中的异步调用_第1张图片

这其实可以用一个现实中的例子来讲述。

今天是小明女朋友的生日,小明想给她一个惊喜,于是想到了订一个蛋糕给她,所以小明打电话给蛋糕店预定,店员回复他说:好的,我们知道了,制作好了会通知你的。于是小明就开开心心的打游戏去了。

在上面的例子中,预定蛋糕就是一个异步过程,我只要通知需要做这件事的人(execute),并拿到回复(Future),然后就可以做其他事情了。然后过一段时间打电话询问蛋糕做好没(isDone),如果没做好,那就请他做好的时候通知我(listener)

所以现在我们有了异步执行,还需要什么呢?

  1. Future和Promise的定义接口
  2. Promise实现

然后,我们理一下需要哪些接口

  1. isDone 判断任务是否完成
  2. addListener
  3. trySuccess 设置任务完成并通知所有listener
  4. sync 同步方法,等待任务完成

定义

首先定义接口

/*listener接口,提供complete方法**/
public interface MyFutureListener>  extends EventListener {

    void operationComplete(F future);
}
/*Future接口**/
public interface MyFuture {

    boolean isDone();

    MyFuture sync() throws InterruptedException ;

    MyFuture addListener(MyFutureListener> listener);


}
/*promise接口**/
public interface MyPromise extends MyFuture{

    boolean trySuccess();

    @Override
    MyPromise addListener(MyFutureListener> listener);


}

isDone

我们假设只有完成和未完成两个状态,Promise内维护着这个状态值(初始为null),那么判断是否完成只需要判断这个值不为空就行了。

    private volatile Object result = null;

    @Override
    public boolean isDone() {
        return result != null;
    }

trySucess

那么最简单的success实现就是给这个对象赋值

    @Override
    public boolean trySuccess() {
        result = new Object();
        return true;
    }

当然,这里很不严谨,我们后面再说。

Listener接口实现

上面我们定义了listener接口,这里要实现addListener方法

    private List>> listeners;

@Override
    public MyPromise addListener(MyFutureListener> listener) {
        synchronized (this) {
            if(listeners == null){
                listeners = new ArrayList>>();
                listeners.add(listener);
            }else {
                listeners.add(listener);
            }
        }
        if (isDone()){
            for (MyFutureListener f: listeners
                    ) {
                f.operationComplete(this);
            }
        }
        return this;
    }

然后完善下success方法,成功的时候调用每一个listener的complete方法。

@Override
    public boolean trySuccess() {
        result = new Object();

        for (MyFutureListener f: listeners
             ) {
            f.operationComplete(this);
        }

        return true;
    }

同步接口实现

同步也很简单,就是先判断任务是否完成,没有完成就wait一下。注意,wait之前我们要保持同步,引入synchronized原语。

@Override
    public MyFuture sync() throws InterruptedException {
        if (isDone()){
            return this;
        }
       
         synchronized (this){
            while (!isDone()) {
            waiters++;
                try {
                    wait();
                }finally {
                    waiters--;
                }
            }
        }
      
        return this;
    }

同理,需要有地方去唤醒它,我们继续完善success方法,最终我们的trySuccess方法如下

private synchronized void checkNotify(){
        if (waiters > 0){
            notifyAll();
        }
    }

 @Override
    public boolean trySuccess() {
        result = new Object();
        checkNotify();
        for (MyFutureListener f: listeners
             ) {
            f.operationComplete(this);
        }

        return true;
    }

Demo

轮子造好了,是时候写个demo测试一下

public class MyExecutorDemo {
    public static void main(String[] args) {

        MyFuture future = asyncHello().addListener((MyFutureListener>) future1 -> System.out.println("监听到完成"));
        if (future.isDone()){
            System.out.println("异步执行完成");
        }else{
            try {
                future.sync();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static MyFuture asyncHello(){
        Executor executor = MyNettyExecutor.newExecutor();
        final DefaultPromise promise = new DefaultPromise();
        executor.execute(() -> {
            System.out.println("Hello Async");
            try {
                //模拟一些操作
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            promise.trySuccess();
        });
        return promise;
    }
}

警告

不可用于生产,这个Future/promise的设计仅仅为了说明异步执行和结果,距离netty中的异步框架还缺少很多。

  1. NULL值检查,整个设计中均没有对对象做NULL的检查,容易引起NullPointException。
  2. 异常处理缺失,对可能失败的地方做异常处理(这也是是否能用于生产的合格检验)
  3. 非完全异步,listener的通知没有使用异步
  4. 待补充(以我现在的水平,暂时想不到)

你可能感兴趣的:(【自己读源码】Netty4.X系列(四) Netty中的异步调用)