利用wait()和notify()实现生产者与消费者问题

最新推荐文章于 2024-07-10 09:44:18 发布

好久不见_别来无恙

最新推荐文章于 2024-07-10 09:44:18 发布

阅读量554

点赞数 1

分类专栏： java

java 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

生产者与消费者问题是并发编程里面的经典问题，下面用wait()和notify()来实现消费者线程和生产者线程的并发执行。

说之前先讲几个概念：

wait()与sleep()的区别：

1.首先sleep()是Thread()类的方法，而wait()是Object类的方法，包括notify()，notifyAll()都是Object类的方法

2.sleep()方法是休眠，阻塞线程的同时仍然会持有锁，也就是说它休眠期间其他线程仍然无法获得锁，同时sleep()休眠时自动醒的；而调用wait()方法时，则自动释放锁，也就是其他线程可以获得锁，而且wait()是无法自动醒的，只有通过notify()或 notifyAll() 才行。

notify()与notifyAll()的区别

notify()一次只能激活一个对这个对象进行wait()的线程，当多个线程都对此对象wait()时，是随机挑一个notify()，而notifyAll()是一次性激活所以对此对象进行wait()的线程。

接下来说说利用wait()和notify()来实现生产者和消费者并发问题：

显然要保证生产者和消费者并发运行不出乱，主要要解决：当生产者线程的缓存区为满的时候，就应该调用wait()来停止生产者继续生产，而当生产者满的缓冲区被消费者消费掉一块时，则应该调用notify()唤醒生产者，通知他可以继续生产；同样，对于消费者，当消费者线程的缓存区为空的时候，就应该调用wait()停掉消费者线程继续消费，而当生产者又生产了一个时就应该调用notify()来唤醒消费者线程通知他可以继续消费了。

当然我们必须在wait()和notify()的时候锁住我们所要操作的对象,这里即缓存区，下面是一个使用wait()的notify()的规范代码模板：

[java]view plain copy
synchronized (sharedObject) { //锁住操作对象  
    while (condition) { //当某个条件下  
    sharedObject.wait(); //进入wait  
          
    }   
    // 做了什么事，就可以激活  
    shareObject.notify();  
}   

下面就贴一下wait和notify实现一个生产者线程和一个消费者线程并发执行的代码：

[java]view plain copy
import java.util.LinkedList;   
import java.util.Queue;   
import java.util.Random;   
  
public class ProducerConsumerInJava {   
public static void main(String args[]) {   
  System.out.println("How to use wait and notify method in Java");   
  System.out.println("Solving Producer Consumper Problem");   
  Queue<Integer> buffer = new LinkedList<>();   
  int maxSize = 10;   
  Thread producer = new Producer(buffer, maxSize, "PRODUCER");   
  Thread consumer = new Consumer(buffer, maxSize, "CONSUMER");<span style="font-family: Arial, Helvetica, sans-serif;"> </span>  

[java]view plain copy
<span style="font-family: Arial, Helvetica, sans-serif;"> //开启生产者和消费者线程</span>  

[java]view plain copy
producer.start();   

[java]view plain copy
consumer.start(); }   

[java]view plain copy
//生产者线程  
class Producer extends Thread   
{ private Queue<Integer> queue;   
  private int maxSize;   
  public Producer(Queue<Integer> queue, int maxSize, String name){   
   super(name); this.queue = queue; this.maxSize = maxSize;   
  }   
  @Override public void run()   
  {   
   while (true)   
    {   
     synchronized (queue) {   
      while (queue.size() == maxSize) { //当缓存区满的时候  
       try {   
        //进入wait  
        queue.wait();   
       } catch (Exception ex) {   
        ex.printStackTrace();   

[java]view plain copy
}   
 }   

[java]view plain copy
//缓存区不为空的时候就可以继续生产，生产后唤醒消费者线程的wait  
 queue.add(i);   

[java]view plain copy
     queue.notifyAll();   
   }   
  }   
 }   
}   

[java]view plain copy
//消费者线程  
class Consumer extends Thread {   
  private Queue<Integer> queue;   
  private int maxSize;   
  public Consumer(Queue<Integer> queue, int maxSize, String name){   
   super(name);   
   this.queue = queue;   
   this.maxSize = maxSize;   
  }   
  @Override public void run() {   
   while (true) {   
    synchronized (queue) {   
     while (queue.isEmpty()) { //当缓存区为空的时候  
        
      try {   
       queue.wait(); //进入wait  
      } catch (Exception ex) {   
       ex.printStackTrace();   
      }   
     }   

[java]view plain copy
    //当缓存区不为空的时候，就可以唤醒所有的wait的消费者线程或者生产者线程  
    queue.notifyAll();   
  }   
 }   
}   

所以从以上可以看出，notify()实际上是可以实现线程间通信，可以在一个线程里通知唤醒另一个线程里的wait，实质上也是因为他们 wait和notify操作的是同一对象，这也是因为wait和notify是相对于Object的。

这就是利用wait和notify实现生产者和消费者问题。