分两段终止。

    啥意思呢？
    就是你想睡觉，但是你憋着一泡屎，不拉出来是睡不着的，那就先拉完屎，然后再去睡觉。

    话糙理不糙，先执行终止处理，再终止线程。

    这就引出了 线程停止的安全性了，都知道不推荐 stop。因为不安全。需要用中断或者信号量去停止线程。我们这个模式就是说的这个。

    发起中断后，Thread.sleep()方法，会接受到这个信号，然后抛出异常。

    1. public class CountupThread extends Thread {
    3.     private int counter = 0;
    4.     private volatile boolean shtdownRequested = false;
    6.     public void shutdownRequest() {
    7.         shtdownRequested = true;
    8.         interrupt();
    9.     }
    11.     public boolean isShtdownRequested() {
    12.         return shtdownRequested;
    13.     }
    15.     @Override
    16.     public void run() {
    17.         super.run();
    18.         try {
    19.             while (!isShtdownRequested()) {
    20.                 doWork();
    21.             }
    22.         } catch (InterruptedException e) {
    23.             e.printStackTrace();
    24.         } finally {
    25.             doShutdowwn();
    26.         }
    27.     }
    29.     private void doShutdowwn() {
    30.         System.out.println("doShutdowwn:counter = " + counter);
    31.     }
    33.     private void doWork() throws InterruptedException {
    34.         counter++;
    35.         System.out.println("doWork: counter" + counter);
    37.         Thread.sleep(500);
    38.     }
    39. }
    1. public class Main {
    3.     public static void main(String[] args) {
    4.         try {
    5.             System.out.println("main BEGIN");
    6.             CountupThread thread = new CountupThread();
    7.             thread.start();
    8.             Thread.sleep(10000);
    9.             System.out.println("main shutdownRequest");
    10.             thread.shutdownRequest();
    11.             System.out.println("main :join");
    13.             thread.join();
    15.         } catch (InterruptedException e) {
    16.             e.printStackTrace();
    17.         }
    18.     }
    19. }