《JUC并发编程 - 高级篇》01 - 进程与线程概述 | 02 - Java线程（创建线程、查看线程、线程常见方法、线程状态）（四）

@Slf4j(topic = "c.Test10")
public class Test10 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
        Thread.sleep(4000);
        tpt.stop();
    }
}
@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination{
    private Thread monitor;
    //启动监控线程
    public void start(){
        monitor = new Thread(() -> {
            while (true) {
                Thread currentThread = Thread.currentThread();
                if (currentThread.isInterrupted()) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);//情况一:阻塞时interrupt
                    log.debug("执行监控记录");//情况二:正常运行时被interrupt
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    currentThread.interrupt();//阻塞被打断后，程序恢复正常运行。再次被打断，将会有一个打断标记，下一轮会被停止线程。
                }
            }
        });
        monitor.start();
    }
    //停止监控线程
    public void stop(){
        monitor.interrupt();
    }
}

@Slf4j(topic = "c.Test11")
public class Test11 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            log.debug("park...");
            LockSupport.park();//线程进入等待状态
            log.debug("unpark...");
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
        }, "t1");
        t1.start();
        Thread.sleep(1);
        t1.interrupt();
    }
}

@Slf4j(topic = "c.Test15")
public class Test15 {
   public static void main(String[] args) throws InterruptedException {
       Thread t1 = new Thread(() -> {
           while (true) {
               if (Thread.currentThread().isInterrupted()) {
                   break;
               }
           }
           log.debug("结束");
       }, "t1");
       t1.setDaemon(true);//将t1设为守护线程
       t1.start();
       Thread.sleep(1000);
       log.debug("结束");
   }
}

@Slf4j(topic = "c.TestState")
public class TestState {
    public static void main(String[] args) throws IOException {
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };//线程刚被创建还没有调用start()
        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while(true) { // runnable
                }
            }
        };//线程正在运行  Runable
        t2.start();
        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };//线程执行完就结束了，对应着TERMINATED
        t3.start();
        Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestState.class) {
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };//带有时间的等待，对应着timed_waiting
        t4.start();
        Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    t2.join(); //等待t2完成后再执行，t2是个死循环，对应着 waiting
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();
        Thread t6 = new Thread("t6") {
            @Override
            public void run() {
                synchronized (TestState.class) { //当前锁对象被t2线程占用，t6处于阻塞状态：blocked
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t6.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state {}", t1.getState());
        log.debug("t2 state {}", t2.getState());
        log.debug("t3 state {}", t3.getState());
        log.debug("t4 state {}", t4.getState());
        log.debug("t5 state {}", t5.getState());
        log.debug("t6 state {}", t6.getState());
        System.in.read();
    }
}

@Slf4j(topic = "c.TestMakeTea")
public class TestMakeTea {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            log.debug("洗水壶");
            sleep(1);
            log.debug("烧开水");
            sleep(15);//sleep是一个用TimeUnit封装的工具类
        }, "老王");
        Thread t2 = new Thread(() -> {
            log.debug("洗茶壶");
            sleep(1);
            log.debug("洗茶叶");
            sleep(2);
            log.debug("拿茶叶");
            sleep(1);
            try {
                t1.join();//等待老王的茶烧好,小王开始泡茶
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            log.debug("泡茶");
        }, "小王");
        t1.start();
        t2.start();
    }
}