2. 程式人生 > >Java 裏如何實現線程間通信

Java 裏如何實現線程間通信

阿新 • • 發佈：2018-10-04
join 耗時 線程池 ble work 比喻 result cti art

正常情況下，每個子線程完成各自的任務就可以結束了。不過有的時候，我們希望多個線程協同工作來完成某個任務，這時就涉及到了線程間通信了。
本文涉及到的知識點：thread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, Callable 等。

下面我從幾個例子作為切入點來講解下 Java 裏有哪些方法來實現線程間通信。

  • 如何讓兩個線程依次執行？
  • 那如何讓 兩個線程按照指定方式有序交叉運行呢？
  • 四個線程 A B C D，其中 D 要等到 A B C 全執行完畢後才執行，而且 A B C 是同步運行的
  • 三個運動員各自準備，等到三個人都準備好後，再一起跑
  • 子線程完成某件任務後，把得到的結果回傳給主線程

如何讓兩個線程依次執行？

假設有兩個線程，一個是線程 A，另一個是線程 B，兩個線程分別依次打印 1-3 三個數字即可。我們來看下代碼：

private static void demo1() {
    Thread A = new Thread(new Runnable() {
        @Override
        public void run() {
            printNumber("A");
        }
    });
    Thread B 
 
= new Thread(new Runnable() {
        @Override
        public void run() {
            printNumber("B");
        }
    });
    A.start();
    B.start();
}

其中的 printNumber(String) 實現如下，用來依次打印 1, 2, 3 三個數字：

private static void printNumber(String threadName) {
    int i=0;
    while (i++ < 3) {
        
 
try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(threadName + "print:" + i);
    }
}

這時我們得到的結果是：

B print: 1
A print: 1
B print: 2
A print: 2
B print: 3
A print: 3

可以看到 A 和 B 是同時打印的。

那麽，如果我們希望 B 在 A 全部打印 完後再開始打印呢？我們可以利用 thread.join() 方法，代碼如下:

private static void demo2() {
    Thread A = new Thread(new Runnable() {
        @Override
        public void run() {
            printNumber("A");
        }
    });
    Thread B = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("B 開始等待 A");
            try {
                A.join();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            printNumber("B");
        }
    });
    B.start();
    A.start();
}

得到的結果如下：

B 開始等待 A
A print: 1
A print: 2
A print: 3
 
B print: 1
B print: 2
B print: 3

所以我們能看到 A.join() 方法會讓 B 一直等待直到 A 運行完畢。

那如何讓 兩個線程按照指定方式有序交叉運行呢？

還是上面那個例子，我現在希望 A 在打印完 1 後，再讓 B 打印 1, 2, 3，最後再回到 A 繼續打印 2, 3。這種需求下，顯然 Thread.join() 已經不能滿足了。我們需要更細粒度的鎖來控制執行順序。

這裏，我們可以利用 object.wait() 和 object.notify() 兩個方法來實現。代碼如下：

/**
 * A 1, B 1, B 2, B 3, A 2, A 3
 */
private static void demo3() {
    Object lock = new Object();
    Thread A = new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (lock) {
                System.out.println("A 1");
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("A 2");
                System.out.println("A 3");
            }
        }
    });
    Thread B = new Thread(new Runnable() {
        @Override
        public void run() {
            synchronized (lock) {
                System.out.println("B 1");
                System.out.println("B 2");
                System.out.println("B 3");
                lock.notify();
            }
        }
    });
    A.start();
    B.start();
}

打印結果如下：

A 1
A waiting…
 
B 1
B 2
B 3
A 2
A 3

正是我們要的結果。

那麽，這個過程發生了什麽呢？

  1. 首先創建一個 A 和 B 共享的對象鎖 lock = new Object();
  2. 當 A 得到鎖後，先打印 1，然後調用 lock.wait() 方法，交出鎖的控制權，進入 wait 狀態；
  3. 對 B 而言，由於 A 最開始得到了鎖，導致 B 無法執行；直到 A 調用 lock.wait() 釋放控制權後， B 才得到了鎖；
  4. B 在得到鎖後打印 1， 2， 3；然後調用 lock.notify() 方法，喚醒正在 wait 的 A;
  5. A 被喚醒後，繼續打印剩下的 2，3。

為了更好理解，我在上面的代碼裏加上 log 方便讀者查看。

private static void demo3() {
    Object lock = new Object();
    Thread A = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("INFO: A 等待鎖");
            synchronized (lock) {
                System.out.println("INFO: A 得到了鎖 lock");
                System.out.println("A 1");
                try {
                    System.out.println("INFO: A 準備進入等待狀態，放棄鎖 lock 的控制權");
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("INFO: 有人喚醒了 A, A 重新獲得鎖 lock");
                System.out.println("A 2");
                System.out.println("A 3");
            }
        }
    });
    Thread B = new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("INFO: B 等待鎖");
            synchronized (lock) {
                System.out.println("INFO: B 得到了鎖 lock");
                System.out.println("B 1");
                System.out.println("B 2");
                System.out.println("B 3");
                System.out.println("INFO: B 打印完畢，調用 notify 方法");
                lock.notify();
            }
        }
    });
    A.start();
    B.start();
}

打印結果如下:

INFO: A 等待鎖
INFO: A 得到了鎖 lock
A 1
INFO: A 準備進入等待狀態，調用 lock.wait() 放棄鎖 lock 的控制權
INFO: B 等待鎖
INFO: B 得到了鎖 lock
B 1
B 2
B 3
INFO: B 打印完畢，調用 lock.notify() 方法
INFO: 有人喚醒了 A, A 重新獲得鎖 lock
A 2
A 3

四個線程 A B C D，其中 D 要等到 A B C 全執行完畢後才執行，而且 A B C 是同步運行的

最開始我們介紹了 thread.join()，可以讓一個線程等另一個線程運行完畢後再繼續執行，那我們可以在 D 線程裏依次 join A B C，不過這也就使得 A B C 必須依次執行，而我們要的是這三者能同步運行。

或者說，我們希望達到的目的是：A B C 三個線程同時運行，各自獨立運行完後通知 D；對 D 而言，只要 A B C 都運行完了，D 再開始運行。針對這種情況，我們可以利用 CountdownLatch 來實現這類通信方式。它的基本用法是：

  1. 創建一個計數器，設置初始值，CountdownLatch countDownLatch = new CountDownLatch(2);
  2. 在 等待線程 裏調用 countDownLatch.await() 方法，進入等待狀態，直到計數值變成 0；
  3. 在 其他線程 裏，調用 countDownLatch.countDown() 方法，該方法會將計數值減小 1；
  4. 當 其他線程 的 countDown() 方法把計數值變成 0 時，等待線程 裏的 countDownLatch.await() 立即退出，繼續執行下面的代碼。

實現代碼如下：

private static void runDAfterABC() {
    int worker = 3;
    CountDownLatch countDownLatch = new CountDownLatch(worker);
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("D is waiting for other three threads");
            try {
                countDownLatch.await();
                System.out.println("All done, D starts working");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();
    for (char threadName=‘A‘; threadName <= ‘C‘; threadName++) {
        final String tN = String.valueOf(threadName);
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(tN + "is working");
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(tN + "finished");
                countDownLatch.countDown();
            }
        }).start();
    }
}

下面是運行結果：

D is waiting for other three threads
A is working
B is working
C is working
 
A finished
C finished
B finished
All done, D starts working

其實簡單點來說，CountDownLatch 就是一個倒計數器，我們把初始計數值設置為3，當 D 運行時，先調用 countDownLatch.await() 檢查計數器值是否為 0，若不為 0 則保持等待狀態；當A B C 各自運行完後都會利用countDownLatch.countDown()，將倒計數器減 1，當三個都運行完後，計數器被減至 0；此時立即觸發 D 的 await() 運行結束，繼續向下執行。

因此，CountDownLatch 適用於一個線程去等待多個線程的情況。

三個運動員各自準備，等到三個人都準備好後，再一起跑

上面是一個形象的比喻，針對 線程 A B C 各自開始準備，直到三者都準備完畢，然後再同時運行 。也就是要實現一種 線程之間互相等待 的效果，那應該怎麽來實現呢？

上面的 CountDownLatch 可以用來倒計數，但當計數完畢，只有一個線程的 await() 會得到響應，無法讓多個線程同時觸發。

為了實現線程間互相等待這種需求，我們可以利用 CyclicBarrier 數據結構，它的基本用法是：

  1. 先創建一個公共 CyclicBarrier 對象，設置 同時等待 的線程數，CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
  2. 這些線程同時開始自己做準備，自身準備完畢後，需要等待別人準備完畢，這時調用 cyclicBarrier.await(); 即可開始等待別人；
  3. 當指定的 同時等待 的線程數都調用了 cyclicBarrier.await();時，意味著這些線程都準備完畢好，然後這些線程才 同時繼續執行。

實現代碼如下，設想有三個跑步運動員，各自準備好後等待其他人，全部準備好後才開始跑：

private static void runABCWhenAllReady() {
    int runner = 3;
    CyclicBarrier cyclicBarrier = new CyclicBarrier(runner);
    final Random random = new Random();
    for (char runnerName=‘A‘; runnerName <= ‘C‘; runnerName++) {
        final String rN = String.valueOf(runnerName);
        new Thread(new Runnable() {
            @Override
            public void run() {
                long prepareTime = random.nextInt(10000) + 100;
                System.out.println(rN + "is preparing for time:" + prepareTime);
                try {
                    Thread.sleep(prepareTime);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                try {
                    System.out.println(rN + "is prepared, waiting for others");
                    cyclicBarrier.await(); // 當前運動員準備完畢，等待別人準備好
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(rN + "starts running"); // 所有運動員都準備好了，一起開始跑
            }
        }).start();
    }
}

打印的結果如下：

A is preparing for time: 4131
B is preparing for time: 6349
C is preparing for time: 8206
 
A is prepared, waiting for others
 
B is prepared, waiting for others
 
C is prepared, waiting for others
 
C starts running
A starts running
B starts running

子線程完成某件任務後，把得到的結果回傳給主線程

實際的開發中，我們經常要創建子線程來做一些耗時任務，然後把任務執行結果回傳給主線程使用，這種情況在 Java 裏要如何實現呢？

回顧線程的創建，我們一般會把 Runnable 對象傳給 Thread 去執行。Runnable定義如下：

public interface Runnable {
    public abstract void run();
}

可以看到 run() 在執行完後不會返回任何結果。那如果希望返回結果呢？這裏可以利用另一個類似的接口類 Callable：

@FunctionalInterface
public interface Callable<V> {
    /**
     * Computes a result, or throws an exception if unable to do so.
     *
     * @return computed result
     * @throws Exception if unable to compute a result
     */
    V call() throws Exception;
}

可以看出 Callable 最大區別就是返回範型 V 結果。

那麽下一個問題就是，如何把子線程的結果回傳回來呢？在 Java 裏，有一個類是配合 Callable 使用的：FutureTask，不過註意，它獲取結果的 get 方法會阻塞主線程。

舉例，我們想讓子線程去計算從 1 加到 100，並把算出的結果返回到主線程。

private static void doTaskWithResultInWorker() {
    Callable<Integer> callable = new Callable<Integer>() {
        @Override
        public Integer call() throws Exception {
            System.out.println("Task starts");
            Thread.sleep(1000);
            int result = 0;
            for (int i=0; i<=100; i++) {
                result += i;
            }
            System.out.println("Task finished and return result");
            return result;
        }
    };
    FutureTask<Integer> futureTask = new FutureTask<>(callable);
    new Thread(futureTask).start();
    try {
        System.out.println("Before futureTask.get()");
        System.out.println("Result:" + futureTask.get());
        System.out.println("After futureTask.get()");
    } catch (InterruptedException e) {
        e.printStackTrace();
    } catch (ExecutionException e) {
        e.printStackTrace();
    }
}

打印結果如下：

Before futureTask.get()
 
Task starts
Task finished and return result
 
Result: 5050
After futureTask.get()

可以看到，主線程調用 futureTask.get() 方法時阻塞主線程；然後 Callable 內部開始執行，並返回運算結果；此時 futureTask.get() 得到結果，主線程恢復運行。

這裏我們可以學到，通過 FutureTask 和 Callable 可以直接在主線程獲得子線程的運算結果，只不過需要阻塞主線程。當然，如果不希望阻塞主線程，可以考慮利用 ExecutorService，把 FutureTask 放到線程池去管理執行。

小結

多線程是現代語言的共同特性，而線程間通信、線程同步、線程安全是很重要的話題。本文針對 Java 的線程間通信進行了大致的講解，後續還會對線程同步、線程安全進行講解。

Java 裏如何實現線程間通信

相關推薦

Java 裏如何實現線程間通信

join 耗時 線程池 ble work 比喻 result cti art 正常情況下，每個子線程完成各自的任務就可以結束了。不過有的時候，我們希望多個線程協同工作來完成某個任務，這時就涉及到了線程間通信了。本文涉及到的知識點：thread.join(), object.

轉：【Java並發編程】之十：使用wait/notify/notifyAll實現線程間通信的幾點重要說明

eight 就會 執行 其中 同步塊 lib public 對象 並發 轉載請註明出處：http://blog.csdn.net/ns_code/article/details/17225469 在Java中，可以通過配合調用Object對象的wait（）方法和n

Java並發編程（10）:使用wait/notify/notifyAll實現線程間通信的幾點重要說明

dex tor 同步 由於 nal 優先 方式 all ron 在Java中，可以通過配合調用Object對象的wait（）方法和notify（）方法或notifyAll（）方法來實現線程間的通信。在線程中調用wait（）方法，將阻塞等待其他線程的通知（其他線程調用noti

NSOperation實現線程間通信

隊列 6.0 。。 app lock 通信 bsp round all p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 14.0px Menlo; color: #008400; background-color: #ffff

轉：【Java並發編程】之十二：線程間通信中notifyAll造成的早期通知問題（含代碼）

data light lan 添加項 article util tool 元素 seconds 轉載請註明出處：http://blog.csdn.net/ns_code/article/details/17229601 如果線程在等待時接到通知，但線程等待的條件

轉：【Java並發編程】之十一：線程間通信中notify通知的遺漏（含代碼）

key wait title net fill article 返回 0ms 註意 轉載請註明出處：http://blog.csdn.net/ns_code/article/details/17228213 notify通知的遺漏很容易理解，即threadA還沒

Java多線程（二） —— 線程安全、線程同步、線程間通信（含面試題集）

err 線程等待 共同點 -c java多線 能夠 空間 而不是 不一致 一、線程安全 多個線程在執行同一段代碼的時候，每次的執行結果和單線程執行的結果都是一樣的，不存在執行結果的二義性，就可以稱作是線程安全的。 講到線程安全問題，其實是指多線程環境下對共享資源的訪問可能會

java線程間通信1--簡單實例

.com getname com spa http 主線程 strong art 子線程 線程通信 　　一、線程間通信的條件 　　　　1、兩個以上的線程訪問同一塊內存 　　　　 2、線程同步，關鍵字 synchronized 　　二、線程間通信主要涉及的方法 　　　

七. 多線程編程9.線程間通信

程序 tro 討論 結束 ava 排隊 被調用 clas www 上述例題無條件的阻塞了其他線程異步訪問某個方法。Java對象中隱式管程的應用是很強大的，但是你可以通過進程間通信達到更微妙的境界。這在Java中是尤為簡單的。像前面所討論過的，多線程通過把任務分成離散的和合乎

【並發編程】線程間通信的方式

管道流 notify prepare implement extend gin public sub ogr 管道流Pipes“管道”是java.io包的一部分，它是Java的特性。而不是Android特有的。一條“管道”為兩個線程建立一個單向的通道。生產者負責寫數據。消

一.線程間通信

管道 inter ima .cn nbsp interrupt 進行 mda 字節 簡介： 等待通知機制的實現 當interrupt（）方法遇到wait（）方法 只通知一個線程 喚醒所有線程

linux高級編程基礎系列：線程間通信

clas ++ lock 種類型 try 所有者 嘗試 .html 基礎 linux高級編程基礎系列：線程間通信 轉載：原文地址http://blog.163.com/jimking_2010/blog/static/1716015352013102510748824/

線程的幾個主要概念----線程間通信；線程死鎖；線程控制：掛起、停止和恢復(線程同步的5種方式)

推薦 處理 本地變量 之間 管理 zed 空間 get ted （一）線程同步（5種同步方式） 1.同步方法--->有synchronized關鍵字修飾的方法。（Java的每個內置對象都有一個內置鎖，當用synchronized修飾方法--->內置鎖保護整個方法

利用管道實現進程間通信

Linux 進程 管道 通信 管道通信 匿名管道 創建匿名管道 int pipe(int pipefd[2]);pipefd[0] : 表示讀管道pipefd[1] : 表示寫管道返回 0表示成功，非零表示創建失敗。 代碼事例: //匿名管道

線程間通信與協作方式之——wait-notify機制

exce 以及 數量 .get extend 不同 end leg static 大家好，上篇文章為大家介紹了線程間通信和協作的一些基本方式，那這篇文章就來介紹一下經典的wait-notify機制吧。 什麽是wait-notify機制？ 想象一下有兩個線程A、B，如果業

【線程間通信：等待喚醒機制】

runnable lean ride system not 必須 this 消費者 clas 在線程安全解決之後，還是一樣存在著如下的問題： A：如果消費者先搶到CPU的執行權，就會去消費數據，但是現在的數據是默認值，沒有意義，應該等著數據有意義，再消費。 B：如果生產者先

線程間通信推薦用隊列

普通 自帶 等級 使用 獲取數據 指定 span 實現 就是 # 隊列是數據安全的，意思是自帶鎖，多線程間通信時，使用隊列是好的，不會出現同一個數據被多個線程搶占，使用其他數據類型進行通信則需要自己實現鎖功能 import queue # 普通先進先出隊列 # q =

線程間通信：Queue

實現 pty maxsize first 先進先出 優先級隊列 出隊 rst ast 線程間使用隊列來互相交換數據，Queue 是提供隊列操作的模塊，常見的隊列如下： FIFO：First In First Out 先進先出隊列，可以用 Queue.Queue() 來實現

Java-JUC（九）：使用Lock替換synchronized，使用Condition的await,singal,singalall替換object的wait,notify,notifyall實現線程間的通信

可能 AR purchase name ati for rac 需要 條件變量 Condition： condition接口描述了可能會與鎖有關的條件變量。這些用法上與使用object.wait訪問隱式監視器類似，但提供了更強大的功能。需要特別指出的是，單個lock可

多進程間通信方式和多線程同步機制總結

post msd 阻塞 ng- div 文件映射 管理 線程 -m 多進程之間通信方式： 文件映射：本地之間 共享內存：本地之間 匿名管道：本地之間 命名管道：跨服務器 郵