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
                        
                      

提示 。

可以使用 Thread.interrupted() 清除打断状态 。

3、不推荐的方法

还有一些不推荐使用的方法，这些方法已过时，容易破坏同步代码块，造成线程死锁 。

方法名	static	功能说明
stop()		停止线程运行
suspend()		挂起（暂停）线程运行
resume()		恢复线程运行

  。

 

---

                        如果您觉得阅读本文对您有帮助，请点一下“
                        
                          推荐
                        
                        ”按钮，您的
                        
                          “推荐”
                        
                        将是我最大的写作动力！欢迎各位转载，但是未经作者本人同意，转载文章之后
                        
                          必须在文章页面明显位置给出作者和原文连接
                        
                        ，否则保留追究法律责任的权利。
                      

最后此篇关于Java并发(九)----线程join、interrupt的文章就讲到这里了,如果你想了解更多关于Java并发(九)----线程join、interrupt的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。