java多线程之wait_JAVA多线程之wait/notify

本文主要学习JAVA多线程中的 wait()方法 与 notify()/notifyAll()方法的用法。

①wait() 与 notify/notifyAll 方法必须在同步代码块中使用&＃xff0c;否则会抛出如下异常&＃xff1a;

②wait() 与  notify/notifyAll() 的执行过程

③中断 调用wait()方法进入等待队列的 线程

④notify 通知的顺序不能错

⑤多线程中测试某个条件的变化用 if 还是用 while&＃xff1f;

①wait() 与 notify/notifyAll 方法必须在同步代码块中使用

wait() 与 notify/notifyAll() 是Object类的方法&＃xff0c;在执行两个方法时&＃xff0c;要先获得锁。那么怎么获得锁呢&＃xff1f;

在这篇&＃xff1a;JAVA多线程之Synchronized关键字--对象锁的特点文章中介绍了使用synchronized关键字获得锁。因此&＃xff0c;wait() 与  notify/notifyAll() 经常与synchronized搭配使用&＃xff0c;即在synchronized修饰的同步代码块或方法里面调用wait() 与  notify/notifyAll()方法。

②wait() 与  notify/notifyAll() 的执行过程

由于 wait() 与  notify/notifyAll() 是放在同步代码块中的&＃xff0c;因此线程在执行它们时&＃xff0c;肯定是进入了临界区中的&＃xff0c;即该线程肯定是获得了锁的。

当线程执行wait()时&＃xff0c;会把当前的锁释放&＃xff0c;然后让出CPU&＃xff0c;进入等待状态。

当执行notify/notifyAll方法时&＃xff0c;会唤醒一个处于等待该 对象锁 的线程&＃xff0c;然后继续往下执行&＃xff0c;直到执行完退出对象锁锁住的区域(synchronized修饰的代码块)后再释放锁。

从这里可以看出&＃xff0c;notify/notifyAll()执行后&＃xff0c;并不立即释放锁&＃xff0c;而是要等到执行完临界区中代码后&＃xff0c;再释放。故&＃xff0c;在实际编程中&＃xff0c;我们应该尽量在线程调用notify/notifyAll()后&＃xff0c;立即退出临界区。即不要在notify/notifyAll()后面再写一些耗时的代码。示例如下&＃xff1a;

1 public class Service {

2

3 public void testMethod(Object lock) {

4 try {

5 synchronized (lock) {

6 System.out.println("begin wait() ThreadName&＃61;"

7 &＃43; Thread.currentThread().getName());

8 lock.wait();

9 System.out.println(" end wait() ThreadName&＃61;"

10 &＃43; Thread.currentThread().getName());

11 }

12 } catch (InterruptedException e) {

13 e.printStackTrace();

14 }

15 }

16

17 public void synNotifyMethod(Object lock) {

18 try {

19 synchronized (lock) {

20 System.out.println("begin notify() ThreadName&＃61;"

21 &＃43; Thread.currentThread().getName() &＃43; " time&＃61;"

22 &＃43; System.currentTimeMillis());

23 lock.notify();

24 Thread.sleep(5000);

25 System.out.println(" end notify() ThreadName&＃61;"

26 &＃43; Thread.currentThread().getName() &＃43; " time&＃61;"

27 &＃43; System.currentTimeMillis());

28 }

29 } catch (InterruptedException e) {

30 e.printStackTrace();

31 }

32 }

33 }

在第3行的testMethod()中调用 wait()&＃xff0c;在第17行的synNotifyMethod()中调用notify()

从上面的代码可以看出&＃xff0c;wait() 与  notify/notifyAll()都是放在同步代码块中才能够执行的。如果在执行wait() 与  notify/notifyAll() 之前没有获得相应的对象锁&＃xff0c;就会抛出&＃xff1a;java.lang.IllegalMonitorStateException异常。

在第8行&＃xff0c;当ThreadA线程执行lock.wait();这条语句时&＃xff0c;释放获得的对象锁lock&＃xff0c;并放弃CPU&＃xff0c;进入等待队列。

当另一个线程执行第23行lock.notify();&＃xff0c;会唤醒ThreadA&＃xff0c;但是此时它并不立即释放锁&＃xff0c;接下来它睡眠了5秒钟(sleep()是不释放锁的&＃xff0c;事实上sleep()也可以不在同步代码块中调用)&＃xff0c;直到第28行&＃xff0c;退出synchronized修饰的临界区时&＃xff0c;才会把锁释放。这时&＃xff0c;ThreadA就有机会获得另一个线程释放的锁&＃xff0c;并从等待的地方起(第9行)起开始执行。

接下来是两个线程类&＃xff0c;线程类ThreadA调用testMethod()方法执行lock.wait();时被挂起&＃xff0c;另一个线程类synNotifyMethodThread调用synNotifyMethod()负责唤醒挂起的线程。代码如下&＃xff1a;

1 public class ThreadA extends Thread {

2 private Object lock;

3

4 public ThreadA(Object lock) {

5 super();

6 this.lock &＃61; lock;

7 }

8

9 &＃64;Override

10 public void run() {

11 Service service &＃61; new Service();

12 service.testMethod(lock);

13 }

14 }

15

16 public class SynNotifyMethodThread extends Thread {

17 private Object lock;

18

19 public SynNotifyMethodThread(Object lock) {

20 super();

21 this.lock &＃61; lock;

22 }

23

24 &＃64;Override

25 public void run() {

26 Service service &＃61; new Service();

27 service.synNotifyMethod(lock);

28 }

29 }

再接下来是测试类&＃xff1a;

1 public class Test {

2

3 public static void main(String[] args) throws InterruptedException {

4

5 Object lock &＃61; new Object();

6

7 ThreadA a &＃61; new ThreadA(lock);

8 a.start();

9

10 //NotifyThread notifyThread &＃61; new NotifyThread(lock);

11 // notifyThread.start();

12

13 SynNotifyMethodThread c &＃61; new SynNotifyMethodThread(lock);

14 c.start();

15 }

16 }

③中断 调用wait()方法进入等待队列的 线程

示例代码如下&＃xff1a;

1 public class Service {

2

3 public void testMethod(Object lock) {

4 try {

5 synchronized (lock) {

6 System.out.println("begin wait()");

7 lock.wait();

8 System.out.println(" end wait()");

9 }

10 } catch (InterruptedException e) {

11 e.printStackTrace();

12 System.out.println("出现异常");

13 }

14 }

15 }

16

17 public class ThreadA extends Thread {

18

19 private Object lock;

20

21 public ThreadA(Object lock) {

22 super();

23 this.lock &＃61; lock;

24 }

25

26 &＃64;Override

27 public void run() {

28 Service service &＃61; new Service();

29 service.testMethod(lock);

30 }

31 }

注意&＃xff0c;在第23行wait()方法是Object类的对象lock调用的。而下面的interrupt()方法是ThreadA类的对象调用的。在ThreadA里面&＃xff0c;将Object的对象作为参数传给了testMethod()方法&＃xff0c;ThreadA的run()方法去调用testMethod()&＃xff0c;从而wait()使ThreadA的线程暂停了(暂停当前执行wait()的线程)。从这里可以看出一个区别&＃xff1a;

Object类中与线程有关的方法&＃xff1a;

1)notify/notifyAll

2)wait()/wait(long)

java.lang.Thread中与之相关的方法&＃xff1a;

1)interrupt()

2)sleep()/sleep(long)

3)join()/suspend()/resume()....

测试类代码如下&＃xff1a;

1 public class Test {

2

3 public static void main(String[] args) {

4

5 try {

6 Object lock &＃61; new Object();

7

8 ThreadA a &＃61; new ThreadA(lock);

9 a.start();

10

11 Thread.sleep(5000);

12

13 a.interrupt();

14 } catch (InterruptedException e) {

15 e.printStackTrace();

16 }

17 }

18 }

当执行第13行的interrupt()时&＃xff0c;处于wait中的线程“立即”被唤醒(一般是立即响应中断请求)&＃xff0c;并抛出异常。此时&＃xff0c;线程也就结束了。

④notify 通知的顺序不能错

假设在线程A中执行wait()&＃xff0c;在线程B中执行notify()。但如果线程B先执行了notify()然后结束了&＃xff0c;线程A才去执行wait()&＃xff0c;那此时&＃xff0c;线程A将无法被正常唤醒了(还可以通过③中提到的interrupt()方法以抛出异常的方式唤醒^~^)。

这篇文章&＃xff1a; JAVA多线程之线程间的通信方式中的第③点提到了notify通知顺序出错会导致 调用wait()进入等待队列的线程再也无法被唤醒了。

⑤多线程中测试某个条件的变化用 if 还是用 while&＃xff1f;

以前一直不明白 当在线程的run()方法中需要测试某个条件时&＃xff0c;为什么用while&＃xff0c;而不用if???直到看到了这个简单的例子&＃xff0c;终于明白了。。。。

这个例子是这样的&＃xff1a;

有两个线程从List中删除数据&＃xff0c;而只有一个线程向List中添加数据。初始时&＃xff0c;List为空&＃xff0c;只有往List中添加了数据之后&＃xff0c;才能删除List中的数据。添加数据的线程向List添加完数据后&＃xff0c;调用notifyAll()&＃xff0c;唤醒了两个删除线程&＃xff0c;但是它只添加了一个数据&＃xff0c;而现在有两个唤醒的删除线程&＃xff0c;这时怎么办&＃xff1f;?

如果用 if 测试List中的数据的个数&＃xff0c;则会出现IndexOutofBoundException&＃xff0c;越界异常。原因是&＃xff0c;List中只有一个数据&＃xff0c;第一个删除线程把数据删除后&＃xff0c;第二个线程再去执行删除操作时&＃xff0c;删除失败&＃xff0c;从而抛出 IndexOutofBoundException。

但是如果用while 测试List中数据的个数&＃xff0c;则不会出现越界异常&＃xff01;&＃xff01;&＃xff01;神奇。

当wait等待的条件发生变化时&＃xff0c;会造成程序的逻辑混乱---即&＃xff0c;List中没有数据了&＃xff0c;再还是有线程去执行删除数据的操作。因此&＃xff0c;需要用while循环来判断条件的变化&＃xff0c;而不是用if。

示例如下&＃xff1a;Add类&＃xff0c;负责添加数据&＃xff1a;

public class Add {

private String lock;

public Add(String lock) {

super();

this.lock &＃61; lock;

}

public void add() {

synchronized (lock) {

ValueObject.list.add("anyString");

lock.notifyAll();

}

}

}

public class ThreadAdd extends Thread {

private Add p;

public ThreadAdd(Add p) {

super();

this.p &＃61; p;

}

&＃64;Override

public void run() {

p.add();

}

}

Subtract类&＃xff0c;负责删除数据----先要进行条件判断&＃xff0c;然后执行wait()&＃xff0c;这意味着&＃xff1a;wait等待的条件可能发生变化&＃xff01;&＃xff01;&＃xff01;

public class Subtract {

private String lock;

public Subtract(String lock) {

super();

this.lock &＃61; lock;

}

public void subtract() {

try {

synchronized (lock) {

if(ValueObject.list.size() &＃61;&＃61; 0) {//将这里的if改成while即可保证不出现越界异常!!!!

System.out.println("wait begin ThreadName&＃61;"

&＃43; Thread.currentThread().getName());

lock.wait();

System.out.println("wait end ThreadName&＃61;"

&＃43; Thread.currentThread().getName());

}

ValueObject.list.remove(0);

System.out.println("list size&＃61;" &＃43; ValueObject.list.size());

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

public class ThreadSubtract extends Thread {

private Subtract r;

public ThreadSubtract(Subtract r) {

super();

this.r &＃61; r;

}

&＃64;Override

public void run() {

r.subtract();

}

}

封装的List队列&＃xff1a;

public class ValueObject {

public static List list &＃61; new ArrayList();

}

测试类&＃xff1a;

public class Run {

public static void main(String[] args) throws InterruptedException {

String lock &＃61; new String("");

Add add &＃61; new Add(lock);

Subtract subtract &＃61; new Subtract(lock);

ThreadSubtract subtract1Thread &＃61; new ThreadSubtract(subtract);

subtract1Thread.setName("subtract1Thread");

subtract1Thread.start();

ThreadSubtract subtract2Thread &＃61; new ThreadSubtract(subtract);

subtract2Thread.setName("subtract2Thread");

subtract2Thread.start();

Thread.sleep(1000);

ThreadAdd addThread &＃61; new ThreadAdd(add);

addThread.setName("addThread");

addThread.start();

}

}