Netty源码分析(一) - 线程生命周期

@Author：zxw
@Email：502513206@qq.com

1.java线程生命周期

对于了解java线程的人应该知道java的线程一共有如下5个状态

public enum State {
        // 线程创建时的状态，此时操作系统中还未创建线程
        NEW,
		// 线程处于就就绪或者可运行状态
        RUNNABLE,
		// 资源占用时，例如synchronized获取锁失败，进入阻塞状态
        BLOCKED,
		// 调用wait()、join)()
        WAITING,
		// 超时等待
        TIMED_WAITING,
		// 线程运行结束
        TERMINATED;
    }

这里引用下大佬公众号上的线程状态转换图

图片来源公众号：低并发编程 @link:[https://mp.weixin.qq.com/s/6kAMFCXT46mWfxRdega1vA]

上面只是帮我们回顾一下java中的线程状态以及线程状态的转换

2.Netty中的线程

我们知道netty是基于主从reactor模式实现的，其中的异步是通过netty的线程组来实现的。即EventLoopGroup，而group只是对线程组的管理，具体的线程执行逻辑则是有EventExecutor类来执行。对于EventExecutornetty也定义了自己的周期，分别如下

SingleThreadEventExecutor

private static final int ST_NOT_STARTED = 1;
private static final int ST_STARTED = 2;
private static final int ST_SHUTTING_DOWN = 3;
private static final int ST_SHUTDOWN = 4;
private static final int ST_TERMINATED = 5;

接下来就看看在netty中对线程组是如何管理的，在源码中发现这样的一行，可以看到创建EventExecutor类时，默认的状态就为1。

private volatile int state = ST_NOT_STARTED;

想要从not_start状态变为start状态，那么肯定是启动时才会改变。通过源码，在启动中找到了如下方法，根据方法名知道这是启动netty内部线程工作的方法，在该方法中会将线程的not_start状态设置为start

private void startThread() {
        if (state == ST_NOT_STARTED) {
            if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
                boolean success = false;
                try {
                    doStartThread();
                    success = true;
                } finally {
                    if (!success) {
                        STATE_UPDATER.compareAndSet(this, ST_STARTED, ST_NOT_STARTED);
                    }
                }
            }
        }
    }

此时EventExecutor的状态如下

当线程启动后，netty就会从其的队列中循环取出数据并执行，如果没有数据则进入阻塞状态。所以只有我们手动调用方法时，EventExecutor中的状态才会改变。
netty提供了两个方法能够让EventExecutor进入shutdown状态。

1. shutdownGracefully：优雅关闭
2. shutdown：关闭

对于第一个优雅关闭，netty中的处理就是如果当前EventExecutor的状态还处于no_start状态，那么则会启动该EventExecutor，通过如下方法实现

 private boolean ensureThreadStarted(int oldState) {
        if (oldState == ST_NOT_STARTED) {
            try {
                doStartThread();
            } catch (Throwable cause) {
                STATE_UPDATER.set(this, ST_TERMINATED);
                terminationFuture.tryFailure(cause);

                if (!(cause instanceof Exception)) {
                    // Also rethrow as it may be an OOME for example
                    PlatformDependent.throwException(cause);
                }
                return true;
            }
        }
        return false;
    }

现在再来梳理下流程图

那么现在只剩最后一个状态ST_TERMINATED，在看看上面的代码，发现catch中有这么一行STATE_UPDATER.set(this, ST_TERMINATED);，可以看到如果当前线程执行异常的话，netty会直接设置EventExecutor的状态为ST_TERMINATED，这里就是执行状态变为关闭的其中之一。那如果是正常执行不出异常的情况下，应当是我们程序结束的时候，那么状态就自然变为ST_TERMINATED了。
在netty中，线程执行完后的后续逻辑中的finally块里，会将状态变更

 try {
      cleanup();
 } finally {
      FastThreadLocal.removeAll();
      STATE_UPDATER.set(SingleThreadEventExecutor.this, ST_TERMINATED);
      threadLock.countDown();
      int numUserTasks = drainTasks();
      if (numUserTasks > 0 && logger.isWarnEnabled()) {
          logger.warn("An event executor terminated with " +
              "non-empty task queue (" + numUserTasks + ')');
      }
    terminationFuture.setSuccess(null);
}

现在netty的EventExecutor的生命周期如下图，虽然和java线程的有几分相似，不过二者之间并没有什么关联，netty将所有的任务都放进了task队列中，队列取出Runnable，然后调用run方法。

其实对于正常的任务进行来说，他的流转顺序就是一个顺序的，如下