【多线程】(三)阻塞式队列和生产者消费者模型


一、什么是阻塞式队列

阻塞式队列(Blocking Queue) 是一种特殊的队列,它提供了线程安全的阻塞操作,以实现在队列为空或已满时的等待和阻塞

阻塞式队列通常用于多线程环境下的生产者-消费者模型,其中生产者线程向队列中插入元素,消费者线程从队列中获取元素。阻塞式队列提供了一种同步机制,使得生产者线程在队列已满时等待插入,而消费者线程在队列为空时等待获取

阻塞式队列的常用操作包括:

  1. 插入元素:

    • put(element): 在队列的尾部插入指定元素,如果队列已满,则阻塞等待空间可用。
  2. 获取元素:

    • take(): 从队列的头部获取并删除元素,如果队列为空,则阻塞等待元素可用。

阻塞式队列的特点是提供了线程安全的阻塞操作,简化了多线程环境下的同步管理。通过阻塞式队列,可以实现高效的生产者-消费者模型,并且避免了手动进行线程间的等待和通知操作。

二、Java库中的阻塞式队列

Java标准库中提供了多个阻塞式队列的实现,下面是几个常用的阻塞式队列实现及其说明:

阻塞式队列实现说明
ArrayBlockingQueue基于数组的有界阻塞队列。在创建时需要指定容量,插入操作会在队列已满时阻塞,获取操作会在队列为空时阻塞。
LinkedBlockingQueue基于链表的可选有界或无界阻塞队列。如果在创建时指定容量,则是有界队列;如果没有指定容量,则是无界队列。无界队列可以在没有上限的情况下存储元素。
PriorityBlockingQueue基于优先级的无界阻塞队列。元素按照指定的优先级顺序进行排序,每次获取操作会返回具有最高优先级的元素。
DelayQueue基于延迟时间的无界阻塞队列。队列中的元素必须实现 Delayed 接口,元素的延迟时间决定了元素可以从队列中获取的时间。
SynchronousQueue一个没有存储的阻塞队列。每个插入操作必须等待相应的删除操作,反之亦然。它主要用于线程之间的直接传输数据。

这些阻塞式队列的实现都位于 java.util.concurrent 包下,都是线程安全的,适用于多线程环境下的并发编程。它们提供了不同的功能和特性,可以根据具体的需求选择合适的实现方式。通过使用这些阻塞式队列,可以简化多线程编程中的同步管理,并提高系统的性能和可靠性。

三、阻塞式队列的模拟实现

实现代码如下:

class MyBlockingQueue {
    // 尾入头出
    private int[] items = new int[1000]; // [head, tail)
    private int head = 0;
    private int tail = 0;
    private int size = 0;

    // 入队列
    public void put(int value) throws InterruptedException {
        synchronized (this) {

            // 当wait被唤醒了,此时的if条件可能还成立,因此将if改成while
            /*if (size == items.length) {
                // 如果队列满了,要进行阻塞
                this.wait();
                // return;
            }*/

            while (size == items.length) {
                // 如果队列满了,要进行阻塞
                this.wait();
            }


            items[tail] = value;
            tail++;

            // 方式一:不直观
            // tail = tail % items.length;

            // 方式二:直观、效率比求余更高
            if (tail >= items.length) {
                tail = 0;
            }

            size++;
            // 生产一个元素,唤醒出队操作
            this.notify();
        }
    }

    // 出队列
    public int take() throws InterruptedException {
        int result = 0;
        synchronized (this) {
            /*if (size == 0) {
                // 队列为空,要进行阻塞
                this.wait();
                // return null;
            }*/

            while (size == 0) {
                // 队列为空,要进行阻塞
                this.wait();
            }

            result = items[head];
            head++;
            if (head >= items.length) {
                head = 0;
            }
            size--;
            // 消耗一个元素,唤醒入队操作
            this.notify();
        }
        return result;
    }

}

以上代码实现了一个简单的阻塞队列(MyBlockingQueue),代码使用一个长度为1000的整数数组(items)作为队列的存储容器,head和tail分别表示队列的头部和尾部的索引,size表示队列中当前元素的数量。

入队操作(put方法):

  • 使用synchronized关键字对方法进行同步,确保在多线程环境下的线程安全性。
  • 当队列已满时,使用while循环而不是if语句进行等待,以避免线程被意外唤醒后直接执行后续操作。
  • 当队列有空间时,将元素放入队列的尾部(tail索引位置),并更新tail的值。
  • 对tail的更新有两种方式,方式一是使用取模操作将tail限制在数组范围内,方式二是通过条件判断来重置tail的值。
  • 增加队列的元素数量(size++)并唤醒可能在等待中的出队操作。

出队操作(take方法):

  • 同样使用synchronized关键字对方法进行同步,确保在多线程环境下的线程安全性。
  • 当队列为空时,使用while循环而不是if语句进行等待,以避免线程被意外唤醒后直接执行后续操作。
  • 当队列非空时,取出队列头部(head索引位置)的元素,并更新head的值。
  • 对head的更新采用方式二,如果head超出了数组的范围(head >= items.length),则将head重置为0。
  • 减少队列的元素数量(size–)并唤醒可能在等待中的入队操作。

四、生产者消费者模型

4.1 什么是生产者消费者模型

生产者-消费者模型是一种常见的并发编程模型,用于协调多个线程之间的数据交换和任务处理。在该模型中,有两类角色:生产者和消费者。

  • 生产者(Producer):生产者负责生成(生产)数据或任务,并将其放入共享的数据结构(例如队列)中。生产者可以是单个线程或多个并发线程。

  • 消费者(Consumer):消费者负责从共享的数据结构中获取(消费)数据或任务,并进行相应的处理。消费者可以是单个线程或多个并发线程。

生产者-消费者模型的主要目标是解耦生产者和消费者,使它们能够独立运行,并以不同的速度进行操作。通过引入共享的数据结构,可以在生产者和消费者之间建立一种同步机制,以确保线程安全和正确的数据交换顺序。

在实际应用中,生产者-消费者模型具有广泛的应用场景,例如多线程任务处理、消息队列、线程池等。它能够有效地利用系统资源,提高系统的并发性和响应性。

4.2 基于阻塞队列实现简单的生产者消费者模型

public class ThreadDemo {
    public static void main(String[] args) {
        BlockingDeque<Integer> blockingDeque = new LinkedBlockingDeque<>();

        // 创建两个线程,t1作为生产者,t2作为消费者
        Thread t1 = new Thread(() -> {
            int count = 0;
            while (true){
                try {
                    System.out.println("线程t1生产元素:" + count);
                    blockingDeque.put(count);
                    count++;
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread t2 = new Thread(() -> {
            while (true){
                Integer res = null;
                try {
                    res = blockingDeque.take();
                    // Thread.sleep(500);
                    System.out.println("线程t2消费元素:" + res);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        t1.start();
        t2.start();
    }
}

这段代码是一个简单的示例,演示了使用阻塞队列实现的生产者-消费者模型。

代码中创建了一个BlockingDeque<Integer>类型的阻塞队列blockingDeque,使用LinkedBlockingDeque作为具体的实现。这个阻塞队列可以存储整数类型的元素,并且支持阻塞的插入和移除操作。

然后,创建了两个线程:t1t2,分别作为生产者和消费者。

  • 生产者线程(t1)使用一个无限循环来模拟持续的生产操作。在每次循环中,它先打印当前生产的元素值,然后使用blockingDeque.put(count)将元素放入阻塞队列中。blockingDeque.put(count)是一个阻塞操作,如果队列已满,生产者线程会被阻塞,直到队列有空间可用。之后,生产者线程将计数值递增,并通过Thread.sleep(500)休眠一段时间,模拟生产的间隔。

  • 消费者线程(t2)同样使用一个无限循环来模拟持续的消费操作。在每次循环中,它使用blockingDeque.take()从阻塞队列中取出一个元素。blockingDeque.take()也是一个阻塞操作,如果队列为空,消费者线程会被阻塞,直到队列有元素可取。取出的元素被赋值给res变量,并打印出消费的元素值。然后,消费者线程继续下一轮循环。

这段代码演示了使用阻塞队列作为生产者和消费者之间的缓冲区,通过阻塞队列的阻塞和唤醒机制,实现了线程间的同步和数据交换。生产者线程不需要关心消费者线程的状态,消费者线程也不需要关心生产者线程的状态,它们通过共享的阻塞队列实现了解耦和线程安全。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
消费者,可以使用Python中的`queue`模块来实现。具体实现如下: ```python import queue import threading import time # 创建一个线程安全的队列 q = queue.Queue() # 生产者线程函数 def producer(): for i in range(10): # 将生产的物品放入队列中 q.put(f'product_{i}') print(f'Producer {threading.current_thread().name} produced product_{i}') time.sleep(1) # 消费者线程函数 def consumer(): while True: # 从队列中取出物品 item = q.get() if item is None: break print(f'Consumer {threading.current_thread().name} consumed {item}') time.sleep(1) # 创建3个生产者线程 for i in range(3): t = threading.Thread(target=producer, name=f'Producer_{i}') t.start() # 创建3个消费者线程 for i in range(3): t = threading.Thread(target=consumer, name=f'Consumer_{i}') t.start() # 等待所有生产者线程结束 for i in range(3): q.put(None) # 等待所有线程结束 for t in threading.enumerate(): if t != threading.current_thread(): t.join() ``` 在这个例子中,我们创建了一个线程安全的队列来存储生产者生产的物品,每个生产者线程都会往队列中放入10个物品,每个消费者线程都会从队列中取出物品并消费。为了让消费者线程能够在队列为空时等待生产者生产物品,我们使用了队列的默认阻塞行为。当队列为空时,`get()`方法会一直阻塞,直到队列中有物品为止。同理,当队列满时,`put()`方法也会阻塞。 最后,我们使用`None`来表示生产者已经生产完毕,消费者线程在取出`None`时就会退出循环,从而结束线程。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

求知.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值