多线程（五）~ wait/notify机制（等待/通知）

首先我们来看一张图，这张图描述了线程操作的几个步骤。

图已经描述的很清楚了，这里除了wait()之外，其他的前面都已经接触过了。

这一章我们主要来说一下和wait()相关的操作，其实和wait()相关的还有另外两个函数notity()和notifyAll()。

这三个函数都是Object类里的方法

wait()：使调用此方法的线程释放共享资源的锁，然后从运行状态退出，进入等待队列，直到被再次唤醒

notify()：随机唤醒等待队列中等待同一个共享资源的“一个”线程，并使该线程退出等待队列，进入可运行状态，也就是说notofy()通知唤醒一个线程。

notifyAll()：使所有正在等待队列中等待同一个共享资源的“全部”线程从等待状态退出，进入可运行状态。

注意：notify()和notifyAll()后并不是直接就释放锁的，而是等notify()后的代码执行完毕后才释放锁。而且这三个方法都必须在synchronize代码块里执行，否则会报错。

 

每个对象都有两个队列，一个是就绪队列，一个是阻塞队列。就绪队列存储了将要获得锁的线程，阻塞队列存储了所有被阻塞的线程。一个线程被唤醒后，才会进入就绪队列，等待CPU的调度，反之，一个线程被wait()之后，线程就进入了阻塞队列，等待下一次被唤醒。

 

线程会释放锁的三种情况：

1.线程任务执行完毕，释放锁。

2.线程调用wait()方法，释放锁。

3.线程执行过程中发生异常，释放锁。

 

生产-消费者模式：

单生产者，单消费者demo：

 

①.生产者：

1. package com.multiThread.bean;
3. publicclass P {
4. privateObject lock;
6. public P(Object lock){
7. this.lock = lock;
8. }
10. publicvoidSetValue(){
11. try{
12. synchronized(lock){
13. if(!ValueObject.value.equals("")){
14. lock.wait();
15. }
16. String value =System.currentTimeMillis()+"_"+System.nanoTime();
17. System.out.println("set值为："+ value);
18. ValueObject.value = value;
19. lock.notify();
20. }
21. }catch(Exception e){
22. e.printStackTrace();
23. }
24. }
26. }

②.消费者

1. package com.multiThread.bean;
3. publicclass C {
5. privateObject lock;
7. public C(Object lock){
8. this.lock = lock;
9. }
11. publicvoid getValue(){
12. try{
13. synchronized(lock){
14. if(ValueObject.value.equals("")){
15. lock.wait();
16. }
17. System.out.println("get的值："+ValueObject.value);
18. ValueObject.value ="";
19. lock.notify();
20. }
21. }catch(Exception e){
22. e.printStackTrace();
23. }
25. }
26. }

③.生产者线程类

1. package com.multiThread.thread;
3. import com.multiThread.bean.P;
5. publicclassThreadPimplementsRunnable{
7. private P p;
9. publicThreadP(P p){
10. this.p = p;
11. }
12. @Override
13. publicvoid run(){
14. while(true){
15. p.SetValue();
16. }
17. }
18. }

④.消费者线程类

1. package com.multiThread.thread;
3. import com.multiThread.bean.C;
5. publicclassThreadCimplementsRunnable{
7. private C c;
8. publicThreadC(C c){
9. this.c = c;
10. }
11. @Override
12. publicvoid run(){
13. while(true){
14. c.getValue();
15. }
16. }
18. }

⑤.测试类

1. package com.multiThread.test.productionConsumption;
3. import com.multiThread.bean.C;
4. import com.multiThread.bean.P;
5. import com.multiThread.thread.ThreadC;
6. import com.multiThread.thread.ThreadP;
8. /**
9. * 等待、通知机制
10. */
11. publicclassProduceCustomTest{
12. publicstaticvoid main(String[] args){
13. Object lock =newObject();
14. P p =new P(lock);
15. C c =new C(lock);
17. ThreadP tp =newThreadP(p);
18. ThreadC tc =newThreadC(c);
20. Thread t1 =newThread(tp);
21. Thread t2 =newThread(tc);
23. t1.start();
24. t2.start();
26. }
27. }

执行结果：

1. set值为：1466176983137_22743411842275
2. get的值：1466176983137_22743411842275
3. set值为：1466176983137_22743412731096
4. get的值：1466176983137_22743412731096
5. set值为：1466176983137_22743412952232
6. get的值：1466176983137_22743412952232
7. set值为：1466176983137_22743413140860
8. get的值：1466176983137_22743413140860
9. .
10. .
11. .

可见生产者和消费者是交替执行的。

这里仅仅是单生产者和消费者。如果是多生产者和消费者会正常运行吗？

答案是否定的。因为notify()之后是随机唤醒一个线程，如果生产者唤醒的是生产者，那么就会一直处于wait()，造成死锁。

解决问题的方法：

    将notify()方法换成notifyAll()

 

 

 

 

 

 

 

 

 

来自为知笔记(Wiz)