ThreadNotify_Pro_Con3-优快云博客

本文介绍了一个使用Java实现的生产者消费者模式案例。通过一个固定大小的队列，一个生产者线程不断地往队列中添加元素，而一个消费者线程则不断从队列中取出并消费这些元素。利用ReentrantLock和Condition来同步生产和消费操作。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

package org.sf.thread;

import java.util.PriorityQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ThreadNotify_Pro_Con3 {
private int queueSize = 10;
     private PriorityQueue<Integer> queue = new PriorityQueue<Integer>(queueSize);
     private Lock lock = new ReentrantLock();
     private Condition notFull = lock.newCondition();
     private Condition notEmpty = lock.newCondition();

     public static void main(String[] args) {
     ThreadNotify_Pro_Con3 test = new ThreadNotify_Pro_Con3();
         Producer producer = test.new Producer();
         Consumer consumer = test.new Consumer();

         producer.start();
         consumer.start();
     }

     class Consumer extends Thread{

         @Override
         public void run() {
             consume();
         }

         private void consume() {
             while(true){
                 lock.lock();
                 try {
                     while(queue.size() == 0){
                         try {
                             System.out.println("队列空，等待数据");
                             notEmpty.await();
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }
                     sleep(1000);// 推迟3秒钟通知
                     queue.poll();                //每次移走队首元素
                     notFull.signal();
                     System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
                 } catch (InterruptedException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
     } finally{
                     lock.unlock();
                 }
             }
         }
     }

     class Producer extends Thread{

         @Override
         public void run() {
             produce();
         }

         private void produce() {
             while(true){
                 lock.lock();
                 try {
                     while(queue.size() == queueSize){
                         try {
                             System.out.println("队列满，等待有空余空间");
                             notFull.await();
                         } catch (InterruptedException e) {
                             e.printStackTrace();
                         }
                     }
                     try {
       sleep(1000);
      } catch (InterruptedException e) {
       // TODO Auto-generated catch block
       e.printStackTrace();
      }// 推迟3秒钟通知
                     queue.offer(1);        //每次插入一个元素
                     notEmpty.signal();
                     System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
                 } finally{
                     lock.unlock();
                 }
             }
         }
     }
}