如何實現執行緒間通訊，有如下三種方法：

1、使用Semaphore (訊號量)類來控制執行緒的等待和釋放

功能：三個執行緒 a 、b 、c 併發執行，b,c 需要 a 執行緒的資料怎麼實現

分析：考慮到多執行緒的不確定性， 因此我們不能確保 ThreadA 就一定先於 ThreadB 和 ThreadC 前執行，就算 ThreadA先執行了， 我們也無法保證 ThreadA 什麼時候才能將變數 num 給初始化完成。 因此我們必須讓 ThreadB 和 Thread去等待 ThreadA 完成任何後發出的訊息

解決方案：解決上面的難題我能想到的兩種方案，一是使用純 Java API 的 Semaphore 類來控制執行緒的等待和釋放，二是使用 Android 提供的 Handler 訊息機制，此處不舉列說明；

import java.util.concurrent.Semaphore;
public class ThreadCommunication {
  private static int num;
  /**
   * 定義一個訊號量，該類內部維持了多個執行緒鎖，可以阻塞多個執行緒，釋放多個執行緒， 執行緒的阻塞和釋放是通過 permit 概念來實現的。執行緒通過semaphore.acquire()方法獲取 permit，如果當前 semaphore 有 permit 則分配給該執行緒，如果沒有則阻塞該執行緒直到 semaphore 呼叫 release（）方法釋放 permit。
   * 建構函式  Semaphore(int permits) ： 建立具有給定的許可數和非公平的公平設定的 Semaphore
   */
  private static Semaphore semaphore = new Semaphore(0);//表示初始時沒有可用的permit

  public static void main(String[] args) {

    Thread threadA = new Thread(new Runnable() {

      public void run() {
        try {
          // 模擬耗時操作之後初始化變數 num
          Thread.sleep(1000);
          num = 1;
          // 初始化完引數後釋放兩個 permit
          semaphore.release(2);

        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
            + "獲取到 num 的值為：" + num);
      }
    },"threadA");
    Thread threadB = new Thread(new Runnable() {

      public void run() {
        try {
      // 獲取 permit，如果 semaphore 沒有可用的 permit 則等待，如果有則消耗一個
          semaphore.acquire();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
            + "獲取到 num 的值為：" + num);
      }
    },"threadB");
    Thread threadC = new Thread(new Runnable() {

      public void run() {
        try {
          // 獲取 permit，如果 semaphore 沒有可用的 permit 則等待，如果有則消耗一個
          semaphore.acquire();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        System.out.println(Thread.currentThread().getName()
            + "獲取到 num 的值為：" + num);
      }
    },"threadC");
    // 同時開啟 3 個執行緒
    threadA.start();
    threadB.start();
    threadC.start();

  }
}

執行結果：

threadA獲取到 num 的值為：1
threadB獲取到 num 的值為：1
threadC獲取到 num 的值為：1

2、傳送訊號的一個簡單方式是在共享物件的變數裡設定訊號值，通過join方法實現

　　執行緒間通訊可以通過傳送訊號，傳送訊號的一個簡單方式是在共享物件的變數裡設定訊號值(並提供set和get方法)。執行緒 A 在一個同步塊裡設定 boolean 型成員變數 hasDataToProcess 為 true，執行緒 B 也在同步塊裡讀取 hasDataToProcess這個成員變數。

package threadLearning.waitSleepExchage;
public class ThreadCommunication2 {
  // 共享的變數
  private boolean hasDataToProcess = false;

  // 取值
  public boolean getHasDataToProcess() {
    return hasDataToProcess;
  }

  // 存值
  public void setHasDataToProcess(boolean hasDataToProcess) {
    this.hasDataToProcess = hasDataToProcess;
  }

  public static void main(String[] args) {
    // 同一個物件
    final ThreadCommunication2 my = new ThreadCommunication2();
    // 執行緒 1 設定 hasDataToProcess 值為 true
    final Thread t1 = new Thread(new Runnable() {
      public void run() {
        my.setHasDataToProcess(true);
      }
    });
    t1.start();
    // 執行緒 2 取這個值 hasDataToProcess
    Thread t2 = new Thread(new Runnable() {
      public void run() {
        try {
          // 等待執行緒 1 完成然後取值
          t1.join();
        } catch (InterruptedException e) {
          e.printStackTrace();
        }
        my.getHasDataToProcess();
        System.out.println("t1 改變以後的值：" + my.getHasDataToProcess());
      }
    });
    t2.start();
  }
}

執行結果為：t1 改變以後的值：true

3、傳送訊號的一個簡單方式是在共享物件的變數裡設定訊號值，通過wait方法實現

專案功能簡介：

執行緒A 對Person的姓名和年齡進行賦值，執行緒B對獲取同一個Person的姓名和年齡並輸出。

如果執行緒A沒有賦值完成，那麼執行緒B則處於等待狀態，線上程A賦值完成後喚醒執行緒B進行輸出

如果執行緒B沒有輸出完成，那麼執行緒A則處於等待狀態，線上程B輸出完成後喚醒執行緒A進行賦值

class Person {
  String name;
  String gender;
  boolean flag = false;// (標記)預設不輸出,即先進行輸入後才能輸出
}

class Input implements Runnable {
  private Person p;
  private int n = 0;

  public Input(Person p) {
    this.p = p;
  }

  public void run() {
    // 別忘了while(true)！！
    while (true) {
      synchronized (p) {// 兩個Runnable用同一個Person初始化，就可保證p是同一個且唯一
        if (p.flag) {
          try {
            p.wait();
          } catch (InterruptedException e) {
          }

        }
        // not "else"
        if (n == 0) {
          p.name = "Jason";
          p.gender = "男";
        } else {
          p.name = "Lily";
          p.gender = "女";
        }
        n = (n + 1) % 2;//是的n在1和0之間切換取值
        p.flag = true;// 修改標誌位
        p.notify();// 喚醒另一個
      }
    }
  }

}

class Output implements Runnable {
  private Person p;

  public Output(Person p) {
    this.p = p;
  }

  public void run() {
    // 別忘了while(true)！！
    while (true) {
      synchronized (p) {
        // 仍然是判斷標誌位，和上面的執行緒輪流等待，喚醒
        if (!p.flag) {
          try {
            p.wait();
          } catch (InterruptedException e) {
          }
        }
        System.out.println(p.name + "..." + p.gender);
        // 別忘了改變標誌位和喚醒另一個
        p.flag = false;// 讓自己回來等待
        p.notify();// 同一個鎖，喚醒鎖上的另一個執行緒
      }// 問題：一個執行緒再次進入鎖，等待，另一個程序在此前喚醒了，此時能進入鎖執行嗎？-->能，wait()即會釋放鎖，也釋放執行資格！
    }
  }
}

public class WaitSleepTest1 {
  public static void main(String[] args) {
    Person p = new Person();

    new Thread(new Input(p)).start();
    new Thread(new Output(p)).start();
  }
}

執行結果為：

Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
Lily...女
Jason...男
......

備註：

• wait和sleep的區別：
• wait():釋放資源，釋放鎖
• sleep():釋放資源，不釋放鎖
• wait():Object的方法，用在同步當中，是同步鎖的方法，以鎖控制執行緒
• sleep():執行緒類Thread本身的靜態方法
• wait(),notify(),notifyAll()方法是用在同步當中的：必須是同步當中的同一把鎖操作執行緒。

所以這幾個方法是Object的方法。試想想不在同步中的多執行緒，由於搶奪執行權結果不定，控制無意義。

以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支援我們。