如何實現線程間通訊，有如下三種方法：
1、使用Semaphore (信號量)類來控制線程的等待和釋放
功能：三個線程 a 、b 、c 并發運行，b,c 需要 a 線程的數據怎么實現
分析：考慮到多線程的不確定性， 因此我們不能確保 ThreadA 就一定先于 ThreadB 和 ThreadC 前執行，就算 ThreadA先執行了， 我們也無法保證 ThreadA 什么時候才能將變量 num 給初始化完成。 因此我們必須讓 ThreadB 和 Thread去等待 ThreadA 完成任何后發出的消息
解決方案：解決上面的難題我能想到的兩種方案，一是使用純 Java API 的 Semaphore 類來控制線程的等待和釋放，二是使用 Android 提供的 Handler 消息機制，此處不舉列說明；
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
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這個成員變量。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
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進行賦值
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
|
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(); }} |
運行結果為：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
Jason...男Lily...女Jason...男Lily...女Jason...男Lily...女Jason...男Lily...女Jason...男Lily...女Jason...男...... |
備注：
- wait和sleep的區別：
- wait():釋放資源，釋放鎖
- sleep():釋放資源，不釋放鎖
- wait():Object的方法，用在同步當中，是同步鎖的方法，以鎖控制線程
- sleep():線程類Thread本身的靜態方法
- wait(),notify(),notifyAll()方法是用在同步當中的：必須是同步當中的同一把鎖操作線程。
所以這幾個方法是Object的方法。試想想不在同步中的多線程，由于搶奪執行權結果不定，控制無意義。
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持服務器之家。
原文鏈接：https://www.cnblogs.com/jiarui-zjb/p/9622653.html
