本篇我们来研究一下 wait() notify() notifyAll() 。
DEMO1： wait() 与 notify()
?
|
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
|
public class Test {
static class ThreadOne extends Thread {
private Callback mCallback;
@Override
public void run() {
work();
if (mCallback != null) {
mCallback.onResult(false);
}
}
// 耗时 3s
private void work() {
System.out.println(" 正在查询数据库 1");
long startTime = System.currentTimeMillis();
while (true) {
if (System.currentTimeMillis() - startTime < 3000) {
continue;
}
break;
}
}
public void setCallback(Callback callback) {
mCallback = callback;
}
public interface Callback {
void onResult(boolean result);
}
}
static class ThreadTest extends Thread {
private Object mLock = new Object();
private ThreadOne mThreadOne;
@Override
public void run() {
workOne();
System.out.println(" 根据结果继续做其他事情 ");
}
private void workOne() {
mThreadOne = new ThreadOne();
mThreadOne.setCallback(new ThreadOne.Callback() {
@Override
public void onResult(boolean result) {
System.out.println(" 查询数据库 1 结束，:" + (result ? " 有数据 " : " 无数据 "));
synchronized (mLock) {
mLock.notify();
System.out.println("--ThreadTest 结束等待 --");
}
}
});
mThreadOne.start();
try {
synchronized (mLock) {
System.out.println("--ThreadTest 进入等待 --");
mLock.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public static void main(String[] var0) {
ThreadTest threadTest = new ThreadTest();
threadTest.start();
}
}
|
DEMO1 输出：
?
|
1
2
3
4
5
|
--ThreadTest 进入等待--
正在查询数据库 1
查询数据库 1 结束，: 无数据
--ThreadTest 结束等待--
根据结果继续做其他事情
|
注意：
使用 wait() 和 notify() 必须在获得同步锁后才能调用，若直接调用会报 java.lang.IllegalMonitorStateException 错误，因为状态由同步锁保护。
wait() 不同于 sleep() 的是 wait() 会释放同步锁。
因为 wait() 和 notify() 是基于同步锁实现的，每个对象都有自己的同步锁，所以 wait() 和 notify() 是 Object 的方法，而不是 Thread。
?
|
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
78
79
80
81
|
public class Test {
private static Object mLock = new Object();
static class MyThread extends Thread {
String mName;
Callback mCallback;
public MyThread(String name){
mName = name;
}
@Override
public void run() {
work();
if (mCallback != null) {
mCallback.onResult(false);
}
}
// 耗时 3s
private void work() {
System.out.println(mName + " 等待 ");
try {
synchronized (mLock) {
mLock.wait();
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void setCallback(Callback callback) {
mCallback = callback;
}
public interface Callback {
void onResult(boolean result);
}
}
static class ThreadTest extends Thread {
@Override
public void run() {
work("db1");
work("db2");
work("db3");
try {
sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (mLock) {
System.out.println(" 唤醒全部 ");
mLock.notifyAll();
}
}
private void work(String name) {
final MyThread myThread = new MyThread(name);
myThread.setCallback(new MyThread.Callback() {
@Override
public void onResult(boolean result) {
System.out.println(myThread.mName + " 回来了 ");
}
});
myThread.start();
}
}
public static void main(String[] var0) {
ThreadTest threadTest = new ThreadTest();
threadTest.start();
}
}
|
DEMO2 输出：
db1 等待
db3 等待
db2 等待
唤醒全部
db3 回来了
db1 回来了
db2 回来了
同一个对象的 wait() 方法可多次在不同的线程中调用，可让不同的线程进入等待（阻塞），可以一个一个 notify()，也可以调用 notifyAll() 一次性全部唤醒。
原文链接：http://hackeris.me/2017/05/07/thread_base_1/
相关文章
猜你喜欢
- 个人网站服务器域名解析设置指南：从购买到绑定全流程 2025-06-10
- 个人网站搭建：如何挑选具有弹性扩展能力的服务器？ 2025-06-10
- 个人服务器网站搭建：如何选择适合自己的建站程序或框架？ 2025-06-10
- 64M VPS建站：能否支持高流量网站运行？ 2025-06-10
- 64M VPS建站：怎样选择合适的域名和SSL证书？ 2025-06-10
