使用 Java 线程中的 BlockingQueue 实现生产者消费者解决方案

javaobject oriented programmingprogramming更新于 2024/9/30 22:04:17

生产者消费者是 Java 并发和多线程中最常见的问题。它出现在同步过程中,有助于管理尝试访问共享资源的多个线程。本文将帮助我们找到使用 Java 线程中的 BlockingQueue 实现生产者消费者解决方案。

生产者消费者问题和 BlockingQueue

了解生产者消费者问题

生产者和消费者是使用共享队列的两个不同实体或进程。该队列具有固定大小的缓冲区。生产者生成信息并将其存储在队列中。消费者消费给定的信息并将其从队列中移除。

实际问题发生

  • 当生产者继续生成数据时,即使缓冲区已满。

  • 当消费者试图移除数据时,即使缓冲区是空的。

  • 生产者或消费者的速度很慢。

  • 两者都试图同时更新缓冲区。

解决方案

  • 当缓冲区已满时,生产者必须停止数据生成。

  • 当缓冲区为空时,消费者必须停止从缓冲区中删除信息。

  • 生产者和消费者仅在缓冲区既不为空也不为空时才工作完整。

BlockingQueue

Java 在"java.util.concurrent"包中提供了 BlockingQueue 接口。使用此队列的主要优点是,在检索和删除项目时,它会等待队列变为非空。此外,在添加项目时,它会等待可用空间。此功能使其成为生产者消费者解决方案的完美选择。

语法

BlockingQueue< Type > nameOfObject = new LinkedBlockingQueue<>();

此处,LinkedBlockingQueue 是实现 BlockingQueue 接口的类。

使用 Java 中的 BlockingQueue 实现生产者消费者解决方案

方法

  • 创建两个类及其相应的构造函数。这两个类都将扩展"Thread"类。第一个类用于生产者,第二个类用于消费者。

  • 在这两个类中,定义"Integer"类型的 BlockingQueue 并将它们作为参数传递给构造函数。此处,"Integer"是一个包装类。

  • 在生产者类中,我们重写内置方法"run()"以从生产者端生成数据。现在,进行 5 次 for 循环,并使用'put()'方法,以 1 秒的间隔将数据存储到 BlockingQueue 中。

  • 在 Consumer 类中,再次覆盖内置方法'run()',使用名为'take()'的内置方法从 Consumer 端使用数据。

  • 在 main() 方法中,定义 BlockingQueue 的对象并将它们作为参数传递给生产者和消费者类的构造函数

示例

import java.util.concurrent.*;
class Producr extends Thread {
   protected BlockingQueue<Integer> blcque;
   Producr(BlockingQueue<Integer> blcque) { // 构造函数
      this.blcque = blcque;
   }
   public void run() { // 重写运行方法
      while (true) {
         for(int i = 1; i <= 5; i++) {
            try {
               System.out.println("Producer is running " + i);
               blcque.put(i); // to produce data
               // produce data with an interval of 1 sec
               Thread.sleep(1000);
            }
           // 处理异常
           catch (InterruptedException exp) {
              System.out.println("An interruption occurred at Producer");
            }
         }
      }
   }
}
class Consumr extends Thread {
   protected BlockingQueue<Integer> blcque;
   Consumr(BlockingQueue<Integer> blcque) { // 构造函数
      this.blcque = blcque;
   }
   public void run() { // overriding run method
      try {
         while (true) {
            Integer elem = blcque.take(); // to consume data
            System.out.println("Consumer is running " + elem);
         }
      }
      // 处理异常
      catch (InterruptedException exp) {
         System.out.println("An interruption occurred at Producer");
      }
   }
}
public class Solution {
   public static void main(String[] args) throws InterruptedException {
        // 创建 BlockingQueue 对象
        BlockingQueue<Integer> bufrShr = new LinkedBlockingQueue<>();
        
        // 将 BlockingQueue 对象作为参数传递
        Producr threadProd = new Producr(bufrShr);
        Consumr threadCon = new Consumr(bufrShr);
        
        // 启动进程
        threadProd.start();
        threadCon.start();
        
        // 5 秒后退出进程
        Thread.sleep(5000);
        System.exit(0);
   }
}

输出

Producer is running 1
Consumer is running 1
Producer is running 2
Consumer is running 2
Producer is running 3
Consumer is running 3
Producer is running 4
Consumer is running 4
Producer is running 5
Consumer is running 5

结论

我们从定义生产者消费者问题开始本文,在下一节中,我们通过引入 BlockingQueue 接口提出了解决该问题的可能方法。最后,我们讨论了一个 Java 程序,该程序向我们展示了如何使用 BlockingQueue 实际解决给定的问题。


相关文章


有用资源