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

1.java线程生命周期

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

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

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

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

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

2.Netty中的线程

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

SingleThreadEventExecutor

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

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

  1. private volatile int state = ST_NOT_STARTED;

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

  1. private void startThread() {
  2.         if (state == ST_NOT_STARTED) {
  3.             if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) {
  4.                 boolean success = false;
  5.                 try {
  6.                     doStartThread();
  7.                     success = true;
  8.                 } finally {
  9.                     if (!success) {
  10.                         STATE_UPDATER.compareAndSet(this, ST_STARTED, ST_NOT_STARTED);
  11.                     }
  12.                 }
  13.             }
  14.         }
  15.     }

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

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

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

  1.  private boolean ensureThreadStarted(int oldState) {
  2.         if (oldState == ST_NOT_STARTED) {
  3.             try {
  4.                 doStartThread();
  5.             } catch (Throwable cause) {
  6.                 STATE_UPDATER.set(this, ST_TERMINATED);
  7.                 terminationFuture.tryFailure(cause);
  9.                 if (!(cause instanceof Exception)) {
  10.                     // Also rethrow as it may be an OOME for example
  11.                     PlatformDependent.throwException(cause);
  12.                 }
  13.                 return true;
  14.             }
  15.         }
  16.         return false;
  17.     }

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

  1.  try {
  2.       cleanup();
  3.  } finally {
  4.       FastThreadLocal.removeAll();
  5.       STATE_UPDATER.set(SingleThreadEventExecutor.this, ST_TERMINATED);
  6.       threadLock.countDown();
  7.       int numUserTasks = drainTasks();
  8.       if (numUserTasks > 0 && logger.isWarnEnabled()) {
  9.           logger.warn("An event executor terminated with " +
  10.               "non-empty task queue (" + numUserTasks + ')');
  11.       }
  12.     terminationFuture.setSuccess(null);
  13. }

现在netty的EventExecutor的生命周期如下图，虽然和java线程的有几分相似，不过二者之间并没有什么关联，netty将所有的任务都放进了task队列中，队列取出Runnable，然后调用run方法。
image.png
其实对于正常的任务进行来说，他的流转顺序就是一个顺序的，如下
image.png