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

时间：2024-12-09 11:03:32

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

多线程（五）~ 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()

相关文章