java中线程池的生命周期

线程池生命周期包括:

• RUNNING:接收新的任务并处理队列中的任务
• SHUTDOWN:不接收新的任务，可是处理队列中的任务
• STOP:不接收新的任务，不处理队列中的任务，同时中断处理中的任务
• TIDYING:全部的任务处理完成，有效的线程数是0
• TERMINATED:terminated()方法执行完毕

转换成TIDYING状态的线程会运行terminated方法。执行完terminated()方法以后，全部等待在awaitTermination()就会返回。

转换过程为：

线程池是空的即有效线程数是0

取消

若是代码可以在某个操做正常彻底以前置入“完成”状态，那么这个操做就称为可取消的。java中提供了协做式机制，使请求取消的任务和代码遵循一种协商好的协议。

线程中断

线程中断就是一种协做机制。它并不会真正的中断一个正在运行的线程，而只是发出中断请求，而后由线程在下一个合适的时刻中断本身。

Thread中的中断方法包括

interrupt

public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();//非当前线程有可能抛出SecurityException

    synchronized (blockerLock) {
        //用于执行可终端的IO操做对应的方法
        Interruptible b = blocker;
        if (b != null) {
            //仅设置终端标记
            interrupt0(); 
            //执行实现了Interruptible接口的防范
            b.interrupt(this);
            return;
        }
    }
    //仅设置终端标记
    interrupt0();
}
复制代码

调用它根据线程的不一样场景，有不一样的结果

1. 若是线程阻塞的是一个能够终端的channel，那么channel会被关闭，同时线程会收到java.nio.channels.ClosedByInterruptException，而且会设置中断标志

   //AbstractInterruptibleChannel中：
   protected final void begin() {
           if (interruptor == null) {
               interruptor = new Interruptible() {
                       public void interrupt(Thread target) {
                           synchronized (closeLock) {
                               if (!open)
                                   return;
                               open = false;
                               interrupted = target;
                               try {
                               //关闭channel
                               AbstractInterruptibleChannel.this.implCloseChannel();
                               } catch (IOException x) { }
                           }
                       }};
           }
           blockedOn(interruptor);
           Thread me = Thread.currentThread();
           if (me.isInterrupted())
               interruptor.interrupt(me);
       }
   复制代码

2. 若是线程阻塞在Selector,执行它的 wakeup方法，于是selector会当即返回，同时会设置中断标志

   //AbstractSelector中：
   protected final void begin() {
       if (interruptor == null) {
           interruptor = new Interruptible() {
                   public void interrupt(Thread ignore) {
                       //执行wakeup,Selector当即返回
                       AbstractSelector.this.wakeup();
                   }};
       }
       AbstractInterruptibleChannel.blockedOn(interruptor);
       Thread me = Thread.currentThread();
       if (me.isInterrupted())
           interruptor.interrupt(me);
   }
   复制代码

3. 若是线程阻塞在wait/join/sleep，线程的中断标志会被清除，并抛出InterruptedException

4. 非上述三种状况，仅设置中断标志

能够看出调用interrupt并不意味着当即中止目标线程正在进行的工做，而只是传递了请求中断的消息

interrupted

清除当前线程的中断状态，并返回以前的值。它实际执行的就是当前线程的isInterrupted(true)

public static boolean interrupted() {
    return currentThread().isInterrupted(true);
}
复制代码

假设当前线程是中断的，此时调用会返回true，若是在下次调用以前没有中断，此时调用会返回false

isInterrupted

返回目标线程的中断状态,只有线程状态是中断才会返回true,其它时候返回false

public boolean isInterrupted() {
    return isInterrupted(false);
}
复制代码

能够看到interrupted和isInterrupted 调用的都是isInterrupted方法，只不过参数不同。它的参数实际表明的是是否要清除中断标记，为true也就清除，在java中的定义以下

private native boolean isInterrupted(boolean ClearInterrupted);
复制代码

参考linux上的实现为
```
bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
  assert(Thread::current() == thread || Threads_lock->owned_by_self(),
    "possibility of dangling Thread pointer");

  OSThread* osthread = thread->osthread();

  bool interrupted = osthread->interrupted();

  if (interrupted && clear_interrupted) {
    osthread->set_interrupted(false); //若是中断了，而且要清除中断标记，就改变终端标记
    // consider thread->_SleepEvent->reset() ... optional optimization
  }

  return interrupted;
}
```
复制代码

响应中断 - 处理InterruptedException

通常策略以下

• 传递异常，使当前方法也成为可中断的
• 恢复中断状态，使得调用栈中的上层代码可以对其进行处理

处理不可中断的阻塞

并不是全部的可阻塞方法或者阻塞机制都能响应中断，中止线程的方法相似于中断

• Java.io中的Socket I/O。InputStream和OutputStream中的read和write等不会响应中断，能够关闭底层的套接字抛出SocketException
• Java.io中的同步I/O。大多数的标准的channel都实现了InterruptibleChannel,它内部通常都是抛出ClosedByInterruptException,并关闭链路
• Selector的异步I/O。阻塞在了Selector.select，经过调用wakeup或者close来提早返回。
• 获取某个锁。因为线程等待某个内置锁，它会认为本身能等到，因此不会处理中断，经过Lock的lockInterruptibly能够同时实现等待锁而且响应中断

Thread.stop自己是不安全的。中止一个线程会释放它全部的锁的监视器，若是有任何一个受这些监视器保护的对象出现了状态不一致，其它的线程也会以不一致的状态查看这个对象，其它线程在这个对象上的任何操做都是没法预料的 为何废弃了Thread.stop

关闭

应用程序准备退出时，这些服务所拥有的线程也应该结束。 ExecutorService提供了两种方法：shutdown和shutdownNow

• shutdown在执行完队列中的全部任务以后，才关闭，它并不会接收新的任务
• shutdownNow则是立马关闭正在执行的任务，并返回尚未开始的任务