Java并发(九)—-线程join、interrupt

技术分享 3年前 (2023-06-02) 0 999+

1、join 方法详解

1.1 为什么需要 join？

下面的代码执行，打印 r 是什么？

static int r = 0; public static void main(String[] args) throws InterruptedException {     test1(); } private static void test1() throws InterruptedException {     log.debug("开始");     Thread t1 = new Thread(() -> {         log.debug("开始");         sleep(1);         log.debug("结束");         r = 10;     });     t1.start();     log.debug("结果为:{}", r);     log.debug("结束"); }

分析

因为主线程和线程 t1 是并行执行的，t1 线程需要 1 秒之后才能算出 r=10
而主线程一开始就要打印 r 的结果，所以只能打印出 r=0

解决方法

用主线程sleep 行不行？为什么？这种方式不推荐，因为不清楚t1线程执行具体的时间
用 join，加在 t1.start() 之后即可，主线程执行到t1.join()时会等待t1线程结束

1.2 等待单个结果

以调用方角度来讲，如果

需要等待结果返回，才能继续运行就是同步
不需要等待结果返回，就能继续运行就是异步

1.2 等待多个结果

问，下面代码 cost 大约多少秒？

static int r1 = 0; static int r2 = 0; public static void main(String[] args) throws InterruptedException {     test2(); } private static void test2() throws InterruptedException {     Thread t1 = new Thread(() -> {         sleep(1);         r1 = 10;     });     Thread t2 = new Thread(() -> {         sleep(2);         r2 = 20;     });     long start = System.currentTimeMillis();     t1.start();     t2.start();     t1.join();     t2.join();     long end = System.currentTimeMillis();     log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start); }

分析如下

第一个 join：等待 t1 时, t2 并没有停止, 而在运行
第二个 join：1s 后, 执行到此, t2 也运行了 1s, 因此也只需再等待 1s

如果颠倒两个 join 呢？

最终都是输出

20:45:43.239 [main] c.TestJoin - r1: 10 r2: 20 cost: 2005

1.3 有时效的 join

等够时间

static int r1 = 0; static int r2 = 0; public static void main(String[] args) throws InterruptedException {     test3(); } public static void test3() throws InterruptedException {     Thread t1 = new Thread(() -> {         sleep(1);         r1 = 10;     });      long start = System.currentTimeMillis();     t1.start();      // 线程执行结束会导致 join 结束     t1.join(1500);     long end = System.currentTimeMillis();     log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start); }

输出

20:48:01.320 [main] c.TestJoin - r1: 10 r2: 0 cost: 1010

没等够时间

static int r1 = 0; static int r2 = 0; public static void main(String[] args) throws InterruptedException {     test3(); } public static void test3() throws InterruptedException {     Thread t1 = new Thread(() -> {         sleep(2);         r1 = 10;     });      long start = System.currentTimeMillis();     t1.start();      // 线程执行结束会导致 join 结束     t1.join(1500);     long end = System.currentTimeMillis();     log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start); }

输出

20:52:15.623 [main] c.TestJoin - r1: 0 r2: 0 cost: 1502

2、interrupt 方法详解

其主要作用是打断 sleep，wait，join 的线程

这几个方法都会让线程进入阻塞状态

打断 sleep 的线程, 会清空打断状态，以 sleep 为例

private static void test1() throws InterruptedException {     Thread t1 = new Thread(()->{         sleep(1);      }, "t1");     t1.start();      sleep(0.5);     t1.interrupt();     log.debug(" 打断状态: {}", t1.isInterrupted()); }

输出

java.lang.InterruptedException: sleep interrupted     at java.lang.Thread.sleep(Native Method)     at java.lang.Thread.sleep(Thread.java:340)     at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)     at cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)     at cn.itcast.n4.TestInterrupt.lambda$test1$3(TestInterrupt.java:59)     at java.lang.Thread.run(Thread.java:745) 21:18:10.374 [main] c.TestInterrupt -  打断状态: false

正常运行状态的如果打断，那么打断标记为true，如果是阻塞状态被打断，那么其打断状态为false。

2.1 打断正常运行的线程

打断正常运行的线程, 不会清空打断状态

private static void test2() throws InterruptedException {     Thread t2 = new Thread(()->{         while(true) {             Thread current = Thread.currentThread();             boolean interrupted = current.isInterrupted();             if(interrupted) {                 log.debug(" 打断状态: {}", interrupted);                 break;             }         }     }, "t2");     t2.start();      sleep(0.5);     t2.interrupt(); }

输出

20:57:37.964 [t2] c.TestInterrupt -  打断状态: true

注意：这个打断标记只是一个标记信号，并不会结束线程的执行，一般是根据这个标记信号来决定是否结束当前线程。

2.2 采用两阶段终止线程，避免stop停止

在一个线程 T1 中如何“优雅”终止线程 T2？这里的【优雅】指的是给 T2 一个料理后事的机会。

错误思路

使用线程对象的 stop() 方法停止线程
- stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其它线程将永远无法获取锁
使用 System.exit(int) 方法停止线程
- 目的仅是停止一个线程，但这种做法会让整个程序都停止

两阶段终止模式

2.2.1 利用 isInterrupted

interrupt 可以打断正在执行的线程，无论这个线程是在 sleep，wait，还是正常运行

class TPTInterrupt {     private Thread thread;     public void start(){         thread = new Thread(() -> {             while(true) {                 Thread current = Thread.currentThread();                 if(current.isInterrupted()) {                     log.debug("料理后事");                     break;                 }                 try {                     Thread.sleep(1000);                     log.debug("将结果保存");                 } catch (InterruptedException e) {                     current.interrupt();  // 设置为true                 }                 // 执行监控操作              }         },"监控线程");         thread.start();     }     public void stop() {         thread.interrupt();     } }

调用

TPTInterrupt t = new TPTInterrupt(); t.start(); Thread.sleep(3500); log.debug("stop"); t.stop();

结果

11:49:42.915 c.TwoPhaseTermination [监控线程] - 将结果保存 11:49:43.919 c.TwoPhaseTermination [监控线程] - 将结果保存 11:49:44.919 c.TwoPhaseTermination [监控线程] - 将结果保存 11:49:45.413 c.TestTwoPhaseTermination [main] - stop  11:49:45.413 c.TwoPhaseTermination [监控线程] - 料理后事

2.2.2 利用停止标记

// 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性 // 我们的例子中，即主线程把它修改为 true 对 t1 线程可见 class TPTVolatile {     private Thread thread;     private volatile boolean stop = false;     public void start(){         thread = new Thread(() -> {             while(true) {                 Thread current = Thread.currentThread();                 if(stop) {                     log.debug("料理后事");                     break;                 }                 try {                     Thread.sleep(1000);                     log.debug("将结果保存");                 } catch (InterruptedException e) {                 }                 // 执行监控操作             }         },"监控线程");         thread.start();     }     public void stop() {         stop = true;         thread.interrupt();     } }

调用

TPTVolatile t = new TPTVolatile(); t.start(); Thread.sleep(3500); log.debug("stop"); t.stop();

结果

11:54:52.003 c.TPTVolatile [监控线程] - 将结果保存 11:54:53.006 c.TPTVolatile [监控线程] - 将结果保存 11:54:54.007 c.TPTVolatile [监控线程] - 将结果保存 11:54:54.502 c.TestTwoPhaseTermination [main] - stop  11:54:54.502 c.TPTVolatile [监控线程] - 料理后事

2.3 打断处于park状态线程

park, 进入WAITING状态，对比wait不需要获得锁就可以让线程WAITING，通过unpark唤醒

打断处于park状态线程, 不会清空打断状态

private static void test3() throws InterruptedException {     Thread t1 = new Thread(() -> {         log.debug("park...");         LockSupport.park();         log.debug("unpark...");         log.debug("打断状态：{}", Thread.currentThread().isInterrupted());     }, "t1");     t1.start();       sleep(1);     t1.interrupt(); }

输出

21:11:52.795 [t1] c.TestInterrupt - park... 21:11:53.295 [t1] c.TestInterrupt - unpark... 21:11:53.295 [t1] c.TestInterrupt - 打断状态：true

如果打断标记已经是 true, 则 park 会失效

private static void test4() {     Thread t1 = new Thread(() -> {         for (int i = 0; i < 5; i++) {             log.debug("park...");             LockSupport.park();             log.debug("打断状态：{}", Thread.currentThread().isInterrupted());         }     });     t1.start();       sleep(1);     t1.interrupt(); }

输出

21:13:48.783 [Thread-0] c.TestInterrupt - park... 21:13:49.809 [Thread-0] c.TestInterrupt - 打断状态：true 21:13:49.812 [Thread-0] c.TestInterrupt - park... 21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 21:13:49.813 [Thread-0] c.TestInterrupt - park... 21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 21:13:49.813 [Thread-0] c.TestInterrupt - park... 21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 21:13:49.813 [Thread-0] c.TestInterrupt - park... 21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true