Fork me on GitHub

java线程:线程的交互通信

线程交互的基础知识

线程交互知识点需要从java.lang.Object的类的三个方法来学习:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// 唤醒在此对象监视器上等待的单个线程。
void notify()
// 唤醒在此对象监视器上等待的所有线程。
void notifyAll()
// 导致当前的线程等待,直到其他线程调用此对象的 notify()方法或 notifyAll()方法。
void wait()
// 导致当前的线程等待,直到其他线程调用此对象的 notify()方法或 notifyAll()方法,或者超过指定的时间量。
void wait(long timeout)
// 导致当前的线程等待,直到其他线程调用此对象的 notify()方法或 notifyAll()方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量。
void wait(long timeout, int nanos)

以上这些方法是帮助线程传递线程关心的时间状态。

关于等待/通知,要记住的关键点是:
  必须从 同步环境内 调用wait()、notify()、notifyAll()方法。线程不能调用对象上等待或通知的方法,除非它拥有那个对象的锁。
  wait()、notify()、notifyAll()都是Object的实例方法。与每个对象具有锁一样,每个对象可以有一个线程列表,他们等待来自该信号(通知)。线程通过执行对象上的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
public class ThreadA {
public static void main(String[] args) {
ThreadB b = new ThreadB();
//启动计算线程
b.start();
//线程A拥有b对象上的锁。线程为了调用wait()或notify()方法,该线程必须是那个对象锁的拥有者
synchronized (b) {
try {
System.out.println("等待对象b完成计算。。。");
//当前线程A等待
b.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("b对象计算的总和是:" + b.total);
}
}
}
class ThreadB extends Thread {
int total;
public void run() {
synchronized (this) {
for (int i = 0; i < 101; i++) {
total += i;
}
//(完成计算了)唤醒在此对象监视器上等待的单个线程,在本例中线程A被唤醒
notify();
}
}
}

1当前线程为: main2当前线程为: main等待对象b完成计算。。。3当前线程为: Thread-04当前线程为: Thread-05当前线程为: main6当前线程为: mainb对象计算的总和是:5050

  千万注意:当在对象上调用wait()方法时,执行该代码的线程立即放弃它在对象上的锁。然而调用notify()时,并不意味着这时线程会放弃其锁。如果线程仍然在完成同步代码,则线程在移出之前不会放弃锁。因此,只要调用notify()并不意味着这时该锁变得可用。

多个线程在等待一个对象锁时候使用notifyAll()

  在多数情况下,最好通知等待某个对象的所有线程。如果这样做,可以在对象上使用notifyAll()让所有在此对象上等待的线程冲出等待区,返回到可运行状态。下面给个例子:

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
//获取计算结果并输出
public class ReaderResult extends Thread {
Calculator c;
public ReaderResult(Calculator c) {
this.c = c;
}
public void run() {
synchronized (c) {
try {
System.out.println(Thread.currentThread() + "等待计算结果。。。");
c.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread() + "计算结果为:" + c.total);
}
}
public static void main(String[] args) {
Calculator calculator = new Calculator();
//启动三个线程,分别获取计算结果
new ReaderResult(calculator).start();
new ReaderResult(calculator).start();
new ReaderResult(calculator).start();
//启动计算线程
calculator.start();
}
//计算线程
public static class Calculator extends Thread {
int total;
public void run() {
synchronized (this) {
for (int i = 0; i < 101; i++) {
total += i;
}
}
//通知所有在此对象上等待的线程
notifyAll();
}
}
}

Thread[Thread-2,5,main]等待计算结果。。。
Exception in thread “Thread-0” Thread[Thread-1,5,main]等待计算结果。。。
Thread[Thread-3,5,main]等待计算结果。。。
java.lang.IllegalMonitorStateException
Thread[Thread-3,5,main]计算结果为:5050
at java.lang.Object.notifyAll(Native Method)
Thread[Thread-1,5,main]计算结果为:5050
at com.changwen.javabase.Thread.ReaderResult$Calculator.run(ReaderResult.java:45)
Thread[Thread-2,5,main]计算结果为:5050

  运行结果表明,程序中有异常,并且多次运行结果可能有多种输出结果。这就是说明,这个多线程的交互程序还存在问题。究竟是出了什么问题,需要深入的分析和思考,下面将做具体分析。
  实际上,上面这个代码中,我们期望的是读取结果的线程在计算线程调用notifyAll()之前等待即可。但是,如果计算线程先执行,并在读取结果线程等待之前调用了notify()方法,那么又会发生什么呢?这种情况是可能发生的。因为无法保证线程的不同部分将按照什么顺序来执行。幸运的是当读取线程运行时,它只能马上进入等待状态—-它没有做任何事情来检查等待的事件是否已经发生。 —-因此,如果计算线程已经调用了notifyAll()方法,那么它就不会再次调用notifyAll(),—-并且等待的读取线程将永远保持等待。这当然是开发者所不愿意看到的问题。
  因此,当等待的事件发生时,需要能够检查notifyAll()通知事件是否已经发生。

-----------------本文结束,感谢您的阅读-----------------