如何实现线程间通讯，有如下三种方法：
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