深入理解執行緒通訊

crossoverJie發表於2018-03-19
執行緒

深入理解執行緒通訊

前言

開發中不免會遇到需要所有子執行緒執行完畢通知主執行緒處理某些邏輯的場景。

或者是執行緒 A 在執行到某個條件通知執行緒 B 執行某個操作。

可以通過以下幾種方式實現：

等待通知機制

等待通知模式是 Java 中比較經典的執行緒通訊方式。

兩個執行緒通過對同一物件呼叫等待 wait() 和通知 notify() 方法來進行通訊。

如兩個執行緒交替列印奇偶數：

public class TwoThreadWaitNotify {

    private int start = 1;

    private boolean flag = false;

    public static void main(String[] args) {
        TwoThreadWaitNotify twoThread = new TwoThreadWaitNotify();

        Thread t1 = new Thread(new OuNum(twoThread));
        t1.setName("A");


        Thread t2 = new Thread(new JiNum(twoThread));
        t2.setName("B");

        t1.start();
        t2.start();
    }

    /**
     * 偶數執行緒
     */
    public static class OuNum implements Runnable {
        private TwoThreadWaitNotify number;

        public OuNum(TwoThreadWaitNotify number) {
            this.number = number;
        }

        @Override
        public void run() {

            while (number.start <= 100) {
                synchronized (TwoThreadWaitNotify.class) {
                    System.out.println("偶數執行緒搶到鎖了");
                    if (number.flag) {
                        System.out.println(Thread.currentThread().getName() + "+-+偶數" + number.start);
                        number.start++;

                        number.flag = false;
                        TwoThreadWaitNotify.class.notify();

                    }else {
                        try {
                            TwoThreadWaitNotify.class.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }

            }
        }
    }


    /**
     * 奇數執行緒
     */
    public static class JiNum implements Runnable {
        private TwoThreadWaitNotify number;

        public JiNum(TwoThreadWaitNotify number) {
            this.number = number;
        }

        @Override
        public void run() {
            while (number.start <= 100) {
                synchronized (TwoThreadWaitNotify.class) {
                    System.out.println("奇數執行緒搶到鎖了");
                    if (!number.flag) {
                        System.out.println(Thread.currentThread().getName() + "+-+奇數" + number.start);
                        number.start++;

                        number.flag = true;

                        TwoThreadWaitNotify.class.notify();
                    }else {
                        try {
                            TwoThreadWaitNotify.class.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}
複製程式碼

輸出結果：

t2+-+奇數93
t1+-+偶數94
t2+-+奇數95
t1+-+偶數96
t2+-+奇數97
t1+-+偶數98
t2+-+奇數99
t1+-+偶數100
複製程式碼

這裡的執行緒 A 和執行緒 B 都對同一個物件 TwoThreadWaitNotify.class 獲取鎖，A 執行緒呼叫了同步物件的 wait() 方法釋放了鎖並進入 WAITING 狀態。

B 執行緒呼叫了 notify() 方法，這樣 A 執行緒收到通知之後就可以從 wait() 方法中返回。

這裡利用了 TwoThreadWaitNotify.class 物件完成了通訊。

有一些需要注意:

  • wait() 、nofify() 、nofityAll() 呼叫的前提都是獲得了物件的鎖(也可稱為物件監視器)。
  • 呼叫 wait() 方法後執行緒會釋放鎖，進入 WAITING 狀態，該執行緒也會被移動到等待佇列中。
  • 呼叫 notify() 方法會將等待佇列中的執行緒移動到同步佇列中，執行緒狀態也會更新為 BLOCKED
  • 從 wait() 方法返回的前提是呼叫 notify() 方法的執行緒釋放鎖，wait() 方法的執行緒獲得鎖。

等待通知有著一個經典正規化：

執行緒 A 作為消費者：

  1. 獲取物件的鎖。
  2. 進入 while(判斷條件)，並呼叫 wait() 方法。
  3. 當條件滿足跳出迴圈執行具體處理邏輯。

執行緒 B 作為生產者:

  1. 獲取物件鎖。
  2. 更改與執行緒 A 共用的判斷條件。
  3. 呼叫 notify() 方法。

虛擬碼如下:

//Thread A

synchronized(Object){
    while(條件){
        Object.wait();
    }
    //do something
}

//Thread B
synchronized(Object){
    條件=false;//改變條件
    Object.notify();
}

複製程式碼

join() 方法

    private static void join() throws InterruptedException {
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("running");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }) ;
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("running2");
                try {
                    Thread.sleep(4000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }) ;

        t1.start();
        t2.start();

        //等待執行緒1終止
        t1.join();

        //等待執行緒2終止
        t2.join();

        LOGGER.info("main over");
    }
複製程式碼

輸出結果:

2018-03-16 20:21:30.967 [Thread-1] INFO  c.c.actual.ThreadCommunication - running2
2018-03-16 20:21:30.967 [Thread-0] INFO  c.c.actual.ThreadCommunication - running
2018-03-16 20:21:34.972 [main] INFO  c.c.actual.ThreadCommunication - main over

複製程式碼

在 t1.join() 時會一直阻塞到 t1 執行完畢，所以最終主執行緒會等待 t1 和 t2 執行緒執行完畢。

其實從原始碼可以看出，join() 也是利用的等待通知機制：

核心邏輯:

    while (isAlive()) {
        wait(0);
    }
複製程式碼

在 join 執行緒完成後會呼叫 notifyAll() 方法，是在 JVM 實現中呼叫，所以這裡看不出來。

volatile 共享記憶體

因為 Java 是採用共享記憶體的方式進行執行緒通訊的，所以可以採用以下方式用主執行緒關閉 A 執行緒:

public class Volatile implements Runnable{

    private static volatile boolean flag = true ;

    @Override
    public void run() {
        while (flag){
            System.out.println(Thread.currentThread().getName() + "正在執行。。。");
        }
        System.out.println(Thread.currentThread().getName() +"執行完畢");
    }

    public static void main(String[] args) throws InterruptedException {
        Volatile aVolatile = new Volatile();
        new Thread(aVolatile,"thread A").start();


        System.out.println("main 執行緒正在執行") ;

        TimeUnit.MILLISECONDS.sleep(100) ;

        aVolatile.stopThread();

    }

    private void stopThread(){
        flag = false ;
    }
}
複製程式碼

輸出結果：

thread A正在執行。。。
thread A正在執行。。。
thread A正在執行。。。
thread A正在執行。。。
thread A執行完畢
複製程式碼

這裡的 flag 存放於主記憶體中，所以主執行緒和執行緒 A 都可以看到。

flag 採用 volatile 修飾主要是為了記憶體可見性，更多內容可以檢視這裡。

CountDownLatch 併發工具

CountDownLatch 可以實現 join 相同的功能，但是更加的靈活。

    private static void countDownLatch() throws Exception{
        int thread = 3 ;
        long start = System.currentTimeMillis();
        final CountDownLatch countDown = new CountDownLatch(thread);
        for (int i= 0 ;i<thread ; i++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    LOGGER.info("thread run");
                    try {
                        Thread.sleep(2000);
                        countDown.countDown();

                        LOGGER.info("thread end");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }

        countDown.await();
        long stop = System.currentTimeMillis();
        LOGGER.info("main over total time={}",stop-start);
    }
複製程式碼

輸出結果:

2018-03-16 20:19:44.126 [Thread-0] INFO  c.c.actual.ThreadCommunication - thread run
2018-03-16 20:19:44.126 [Thread-2] INFO  c.c.actual.ThreadCommunication - thread run
2018-03-16 20:19:44.126 [Thread-1] INFO  c.c.actual.ThreadCommunication - thread run
2018-03-16 20:19:46.136 [Thread-2] INFO  c.c.actual.ThreadCommunication - thread end
2018-03-16 20:19:46.136 [Thread-1] INFO  c.c.actual.ThreadCommunication - thread end
2018-03-16 20:19:46.136 [Thread-0] INFO  c.c.actual.ThreadCommunication - thread end
2018-03-16 20:19:46.136 [main] INFO  c.c.actual.ThreadCommunication - main over total time=2012
複製程式碼

CountDownLatch 也是基於 AQS(AbstractQueuedSynchronizer) 實現的，更多實現參考 ReentrantLock 實現原理

  • 初始化一個 CountDownLatch 時告訴併發的執行緒，然後在每個執行緒處理完畢之後呼叫 countDown() 方法。
  • 該方法會將 AQS 內建的一個 state 狀態 -1 。
  • 最終在主執行緒呼叫 await() 方法，它會阻塞直到 state == 0 的時候返回。

CyclicBarrier 併發工具

    private static void cyclicBarrier() throws Exception {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(3) ;

        new Thread(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("thread run");
                try {
                    cyclicBarrier.await() ;
                } catch (Exception e) {
                    e.printStackTrace();
                }

                LOGGER.info("thread end do something");
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("thread run");
                try {
                    cyclicBarrier.await() ;
                } catch (Exception e) {
                    e.printStackTrace();
                }

                LOGGER.info("thread end do something");
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("thread run");
                try {
                    Thread.sleep(5000);
                    cyclicBarrier.await() ;
                } catch (Exception e) {
                    e.printStackTrace();
                }

                LOGGER.info("thread end do something");
            }
        }).start();

        LOGGER.info("main thread");
    }
複製程式碼

CyclicBarrier 中文名叫做屏障或者是柵欄，也可以用於執行緒間通訊。

它可以等待 N 個執行緒都達到某個狀態後繼續執行的效果。

  1. 首先初始化執行緒參與者。
  2. 呼叫 await() 將會在所有參與者執行緒都呼叫之前等待。
  3. 直到所有參與者都呼叫了 await() 後，所有執行緒從 await() 返回繼續後續邏輯。

執行結果:

2018-03-18 22:40:00.731 [Thread-0] INFO  c.c.actual.ThreadCommunication - thread run
2018-03-18 22:40:00.731 [Thread-1] INFO  c.c.actual.ThreadCommunication - thread run
2018-03-18 22:40:00.731 [Thread-2] INFO  c.c.actual.ThreadCommunication - thread run
2018-03-18 22:40:00.731 [main] INFO  c.c.actual.ThreadCommunication - main thread
2018-03-18 22:40:05.741 [Thread-0] INFO  c.c.actual.ThreadCommunication - thread end do something
2018-03-18 22:40:05.741 [Thread-1] INFO  c.c.actual.ThreadCommunication - thread end do something
2018-03-18 22:40:05.741 [Thread-2] INFO  c.c.actual.ThreadCommunication - thread end do something
複製程式碼

可以看出由於其中一個執行緒休眠了五秒，所有其餘所有的執行緒都得等待這個執行緒呼叫 await() 。

該工具可以實現 CountDownLatch 同樣的功能，但是要更加靈活。甚至可以呼叫 reset() 方法重置 CyclicBarrier (需要自行捕獲 BrokenBarrierException 處理) 然後重新執行。

執行緒響應中斷

public class StopThread implements Runnable {
    @Override
    public void run() {

        while ( !Thread.currentThread().isInterrupted()) {
            // 執行緒執行具體邏輯
            System.out.println(Thread.currentThread().getName() + "執行中。。");
        }

        System.out.println(Thread.currentThread().getName() + "退出。。");

    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new StopThread(), "thread A");
        thread.start();

        System.out.println("main 執行緒正在執行") ;

        TimeUnit.MILLISECONDS.sleep(10) ;
        thread.interrupt();
    }


}
複製程式碼

輸出結果:

thread A執行中。。
thread A執行中。。
thread A退出。。
複製程式碼

可以採用中斷執行緒的方式來通訊，呼叫了 thread.interrupt() 方法其實就是將 thread 中的一個標誌屬性置為了 true。

並不是說呼叫了該方法就可以中斷執行緒，如果不對這個標誌進行響應其實是沒有什麼作用(這裡對這個標誌進行了判斷)。

但是如果丟擲了 InterruptedException 異常，該標誌就會被 JVM 重置為 false。

執行緒池 awaitTermination() 方法

如果是用執行緒池來管理執行緒，可以使用以下方式來讓主執行緒等待執行緒池中所有任務執行完畢:

    private static void executorService() throws Exception{
        BlockingQueue<Runnable> queue = new LinkedBlockingQueue<>(10) ;
        ThreadPoolExecutor poolExecutor = new ThreadPoolExecutor(5,5,1, TimeUnit.MILLISECONDS,queue) ;
        poolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("running");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        poolExecutor.execute(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("running2");
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        poolExecutor.shutdown();
        while (!poolExecutor.awaitTermination(1,TimeUnit.SECONDS)){
            LOGGER.info("執行緒還在執行。。。");
        }
        LOGGER.info("main over");
    }
複製程式碼

輸出結果:

2018-03-16 20:18:01.273 [pool-1-thread-2] INFO  c.c.actual.ThreadCommunication - running2
2018-03-16 20:18:01.273 [pool-1-thread-1] INFO  c.c.actual.ThreadCommunication - running
2018-03-16 20:18:02.273 [main] INFO  c.c.actual.ThreadCommunication - 執行緒還在執行。。。
2018-03-16 20:18:03.278 [main] INFO  c.c.actual.ThreadCommunication - 執行緒還在執行。。。
2018-03-16 20:18:04.278 [main] INFO  c.c.actual.ThreadCommunication - main over
複製程式碼

使用這個 awaitTermination() 方法的前提需要關閉執行緒池，如呼叫了 shutdown() 方法。

呼叫了 shutdown() 之後執行緒池會停止接受新任務，並且會平滑的關閉執行緒池中現有的任務。

管道通訊

    public static void piped() throws IOException {
        //面向於字元 PipedInputStream 面向於位元組
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();

        //輸入輸出流建立連線
        writer.connect(reader);


        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("running");
                try {
                    for (int i = 0; i < 10; i++) {

                        writer.write(i+"");
                        Thread.sleep(10);
                    }
                } catch (Exception e) {

                } finally {
                    try {
                        writer.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }

            }
        });
        Thread t2 = new Thread(new Runnable() {
            @Override
            public void run() {
                LOGGER.info("running2");
                int msg = 0;
                try {
                    while ((msg = reader.read()) != -1) {
                        LOGGER.info("msg={}", (char) msg);
                    }

                } catch (Exception e) {

                }
            }
        });
        t1.start();
        t2.start();
    }
複製程式碼

輸出結果:

2018-03-16 19:56:43.014 [Thread-0] INFO  c.c.actual.ThreadCommunication - running
2018-03-16 19:56:43.014 [Thread-1] INFO  c.c.actual.ThreadCommunication - running2
2018-03-16 19:56:43.130 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=0
2018-03-16 19:56:43.132 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=1
2018-03-16 19:56:43.132 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=2
2018-03-16 19:56:43.133 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=3
2018-03-16 19:56:43.133 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=4
2018-03-16 19:56:43.133 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=5
2018-03-16 19:56:43.133 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=6
2018-03-16 19:56:43.134 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=7
2018-03-16 19:56:43.134 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=8
2018-03-16 19:56:43.134 [Thread-1] INFO  c.c.actual.ThreadCommunication - msg=9
複製程式碼

Java 雖說是基於記憶體通訊的，但也可以使用管道通訊。

需要注意的是，輸入流和輸出流需要首先建立連線。這樣執行緒 B 就可以收到執行緒 A 發出的訊息了。

實際開發中可以靈活根據需求選擇最適合的執行緒通訊方式。

號外

最近在總結一些 Java 相關的知識點，感興趣的朋友可以一起維護。

地址: github.com/crossoverJi…

深入理解執行緒通訊

相關文章