并发编程学习（二）：两阶段终止模式（two phase termination）

1、两阶段终止模式：（two phase termination）

        在一个线程t1中如何优雅的终止线程t2 ? 这里的优雅指的是给t2一个料理后事的机会。

具体流程示意图：

睡眠2s :  该行为是为了防止while(true) 占用大量的内存资源，通过睡眠2s可以大幅度减少内存消耗。

睡眠2s 期间被打断，会抛出异常，并清除打断标记，所以需要线程内部自己重新设置打断标记。

 代码示例：

package com.example.test.thread;

import lombok.extern.slf4j.Slf4j;

import java.util.concurrent.TimeUnit;

@Slf4j
public class TestTwoPhaseTermination {

    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination twoPhaseTermination = new TwoPhaseTermination();

        twoPhaseTermination.start();

        TimeUnit.SECONDS.sleep(4);

        twoPhaseTermination.stop();
    }
}


@Slf4j
class TwoPhaseTermination {

    private Thread monitor;

    // 启动监控线程
    public void start() {
        monitor = new Thread(()-> {
            while (true) {
                Thread currentThread = Thread.currentThread();
                if (currentThread.isInterrupted()) {
                    log.debug("monitor线程被打断，料理后事...");
                    break;
                }

                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    // 睡眠期间被打断，会抛出异常，并会清除打断记录，
                    // 此处重新设置打断记录
                    currentThread.interrupt();
                }
            }
        },"monitor");
        monitor.start();
    }

    // 停止监控线程
    public void stop() {
        monitor.interrupt();
    }
}

执行结果：

2、两阶段终止模式：（two phase termination）优化

使用volitale关键字，保证变量多个线程可见。

 public static void main(String[] args) throws InterruptedException {
//        TwoPhaseTermination twoPhaseTermination = new TwoPhaseTermination();
        TwoPhaseTerminationOptimization twoPhaseTermination = new TwoPhaseTerminationOptimization();

        twoPhaseTermination.start();

        TimeUnit.SECONDS.sleep(4);

        twoPhaseTermination.stop();
    }

/**
 * 两阶段终止模式优化：使用volatile
 */
@Slf4j
class TwoPhaseTerminationOptimization {

    private Thread thread;
    private volatile boolean stop = false; // 停止标识

    // 启动监控线程
    public void start() {
        thread = new Thread(()-> {
            while (true) {
                Thread currentThread = Thread.currentThread();
                if (stop) {
                    log.debug("料理后事...");
                    break;
                }

                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"t1");
        thread.start();
    }

    // 停止监控线程
    public void stop() {
        stop = true;
        // 为了防止给stop设置为true时，thread线程处于sleep中，导致无法立即结束thread线程; 
        // 可以采用 thread.interrupt() 导致sleep中的线程打断异常，从而快速结束thread线程
        thread.interrupt(); 
    }
}