Java併發(九)----線程join、interrupt

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()		恢復線程運行