阻塞队列与生产者消费者模型


一、阻塞队列是什么?

1.阻塞队列,首先是一个队列,队列的特点是先进先出

2.阻塞队列,再者是阻塞,阻塞会有以下特点:

1.如果队列为空,执行出队列操作,就会阻塞,阻塞到另一个线程往队列里面添加元素为止(队列不空)
2.如果队列为满,执行入队列操作,就会阻塞,阻塞到另一个线程从队列里面取走元素为止(队列不满)

可以通过这样一个例子来理解阻塞队列: 假设有一个水槽和两个水龙头,一个是进水管负责注水,另一个是出水管负责排水。我们可以把水槽看作是一个阻塞队列,进水管添加的水就是入队列的操作,而出水管放掉的水就是出队列的操作。

如果水槽已满,那么进水管会被阻塞,无法再往水槽里注入更多的水,直到出水管放出一些水腾出了空间。同样地,如果水槽已经完全排空,那么出水管就会被阻塞,必须等进水管注入一些水后才能再次放出水。这样,就可以保证水槽的水量始终在一个合理的范围内,并且不会出现因为溢出或排空导致的问题。

阻塞队列常用于生产者和消费者的场景中,下面我们来介绍一下。

二、生产者消费者模型

1.什么是生产者消费者模型

生产者消费者模型是一种用于解决多线程并发问题的编程模式。在这个模型中,生产者负责生产数据,而消费者负责处理这些数据。这种模型的主要目标是将数据的生产和消费过程解耦开来,使得它们可以独立地进行开发、测试和优化。

如何来理解这个模型呢?以包饺子为例,一个人负责生产饺子皮,进行擀皮,并将饺子皮放在桌子上,被称为生产者,一个人负责包饺子,消耗饺子皮,从桌子上拿饺子皮,被称为消费者,桌子就是阻塞队列,如果生产饺子皮的人慢了,那么包饺子的就要等一会,如果我生产太快了,桌子上放不下了,我就等一会。

2.生产者消费者模型的两大好处

1.解耦合

实现了发送方和接受方的"解耦合"

这个模型通过引入一个缓冲区或仓库来解决生产者和消费者之间的直接通信问题,从而使得两者之间达到了解耦的效果。具体来说,生产者负责向缓冲区添加数据,而消费者则从缓冲区中取出数据进行消费。

这种解耦的优势非常明显:即使生产者和消费者的代码发生变化,由于它们之间没有直接的交互,所以不会对彼此产生影响。例如,如果生产者生产数据的速度非常快,而消费者消费数据的速度较慢,那么生产者不需要等待消费者完成,而是继续生产并将数据放入缓冲区。反之,如果消费者的速度超过了生产者,消费者也不会因为等待数据而停滞不前,而是可以从缓冲区中获取数据并进行处理。

2.削峰填谷

生产者消费者模型的第二个好处是做到"削峰填谷“,保证系统稳定性

在这里插入图片描述

在生产者消费者模型中,"削峰填谷"是一个关键特性,该特性在大坝这个实际例子中得到了生动的体现。

  1. 在雨季时,大坝会通过蓄水来承担上游的冲击,从而防止下游的水流量过大导致洪灾,这个过程就是典型的“削峰”。
  2. 当水流量适中时,大坝再逐渐放水,以满足下游的需求,这就好比是“填谷”。

三、Java标准库中的阻塞队列

import java.util.concurrent.BlockingDeque;
import java.util.concurrent.LinkedBlockingDeque;

/**
 * JAVA标准库中提供的阻塞队列
 */
public class test6 {
    public static void main(String[] args) throws InterruptedException {
        BlockingDeque<String> blockingDeque = new LinkedBlockingDeque<>();
        blockingDeque.put("hello");
        blockingDeque.put("world");
        String res = blockingDeque.take();
        System.out.println(res);
        res = blockingDeque.take();
        System.out.println(res);
        res = blockingDeque.take();
        System.out.println(res);
    }
}


总结

阻塞队列,也被称为BlockingQueue,是一个支持两种附加操作的队列。第一种是当队列为空时,获取元素的线程会等待队列变为非空。第二种是当队列满时,存储元素的线程会等待队列变得可用。这种队列在数据结构中的功能可以类比为:线程1向阻塞队列中添加元素,同时线程2从阻塞队列中移除元素,通常用于生产者和消费者的场景中。

  • 18
    点赞
  • 23
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 下面是一个简单的基于阻塞队列的生产者与消费者模型的 C 语言代码示例: ``` #include <stdio.h> #include <pthread.h> #include <semaphore.h> #define MAX_ITEMS 5 int queue[MAX_ITEMS]; int front = 0; int rear = -1; int count = 0; sem_t empty_sem; sem_t full_sem; pthread_mutex_t queue_mutex; void *producer(void *arg) { int item; while (1) { item = rand() % 100; sem_wait(&empty_sem); pthread_mutex_lock(&queue_mutex); queue[++rear] = item; count++; printf("Produced item: %d\n", item); pthread_mutex_unlock(&queue_mutex); sem_post(&full_sem); } } void *consumer(void *arg) { int item; while (1) { sem_wait(&full_sem); pthread_mutex_lock(&queue_mutex); item = queue[front++]; count--; printf("Consumed item: %d\n", item); pthread_mutex_unlock(&queue_mutex); sem_post(&empty_sem); } } int main() { pthread_t producer_thread, consumer_thread; sem_init(&empty_sem, 0, MAX_ITEMS); sem_init(&full_sem, 0, 0); pthread_mutex_init(&queue_mutex, NULL); pthread_create(&producer_thread, NULL, producer, NULL); pthread_create(&consumer_thread, NULL, consumer, NULL); pthread_join(producer_thread, NULL); pthread_join(consumer_thread, NULL); return 0; } ``` 说明:这里使用了两个信号量 `empty_sem` 和 `full_sem` 以及一个互斥锁 `queue_mutex` 来实现生产者与消费者间的同步和互斥。当队列为空时,消费者线程将等待 `full_sem` 信号量;当队列已满时,生产者线程将等待 `empty_sem` 信号量。读写队列数据时,使用互斥锁来保证 ### 回答2: 生产者-消费者模型是一种常见的多线程编程模型,在多线程环境下,由一个或多个生产者线程生成数据并将其放入缓冲区,然后由一个或多个消费者线程从缓冲区中取出数据进行消费。阻塞队列是一个可以自动阻塞或唤醒线程的队列,当队列为空时,消费者线程将被阻塞,直到有生产者线程向队列中放入数据;当队列满时,生产者线程将被阻塞,直到有消费者线程从队列中取出数据。 下面是一个基于C语言的简单生产者-消费者模型,使用阻塞队列实现。 #include <pthread.h> #include <stdio.h> #include <stdlib.h> #define MAX_QUEUE_SIZE 10 typedef struct { int data[MAX_QUEUE_SIZE]; int front; int rear; int count; pthread_mutex_t mutex; pthread_cond_t not_full; pthread_cond_t not_empty; } BlockingQueue; void init_queue(BlockingQueue* queue) { queue->front = 0; queue->rear = 0; queue->count = 0; pthread_mutex_init(&queue->mutex, NULL); pthread_cond_init(&queue->not_full, NULL); pthread_cond_init(&queue->not_empty, NULL); } void enqueue(BlockingQueue* queue, int item) { pthread_mutex_lock(&queue->mutex); while (queue->count >= MAX_QUEUE_SIZE) { pthread_cond_wait(&queue->not_full, &queue->mutex); } queue->data[queue->rear] = item; queue->rear = (queue->rear + 1) % MAX_QUEUE_SIZE; queue->count++; pthread_cond_signal(&queue->not_empty); pthread_mutex_unlock(&queue->mutex); } int dequeue(BlockingQueue* queue) { pthread_mutex_lock(&queue->mutex); while (queue->count <= 0) { pthread_cond_wait(&queue->not_empty, &queue->mutex); } int item = queue->data[queue->front]; queue->front = (queue->front + 1) % MAX_QUEUE_SIZE; queue->count--; pthread_cond_signal(&queue->not_full); pthread_mutex_unlock(&queue->mutex); return item; } void* producer(void* arg) { BlockingQueue* queue = (BlockingQueue*)arg; for (int i = 1; i <= 100; i++) { enqueue(queue, i); printf("Producer produced: %d\n", i); } pthread_exit(NULL); } void* consumer(void* arg) { BlockingQueue* queue = (BlockingQueue*)arg; for (int i = 1; i <= 100; i++) { int item = dequeue(queue); printf("Consumer consumed: %d\n", item); } pthread_exit(NULL); } int main() { BlockingQueue queue; init_queue(&queue); pthread_t producer_thread; pthread_t consumer_thread; pthread_create(&producer_thread, NULL, producer, &queue); pthread_create(&consumer_thread, NULL, consumer, &queue); pthread_join(producer_thread, NULL); pthread_join(consumer_thread, NULL); return 0; } 上述代码中,定义了一个BlockingQueue结构体来表示阻塞队列,使用互斥锁(mutex)和条件变量(cond)来实现线程之间的同步和互斥。生产者线程使用enqueue函数将数据放入队列,消费者线程使用dequeue函数从队列中取出数据。生产者线程生成1到100的数据并放入队列,消费者线程从队列中取出数据并输出。 此模型通过互斥锁和条件变量的配合,实现了生产者线程与消费者线程之间的同步,当队列满时生产者线程阻塞等待,当队列空时消费者线程阻塞等待,从而避免了线程间的数据竞争和死锁问题。 ### 回答3: 阻塞队列是一种常用的线程同步机制,它提供了安全的生产者-消费者模型。下面是一个使用C语言实现的简单的基于阻塞队列的生产者与消费者模型的示例: ```c #include <stdio.h> #include <stdlib.h> #include <pthread.h> #define BUFFER_SIZE 5 typedef struct { int buffer[BUFFER_SIZE]; int size; int in; int out; pthread_mutex_t mutex; pthread_cond_t full; pthread_cond_t empty; } Queue; void produce(Queue* q, int val) { pthread_mutex_lock(&(q->mutex)); while (q->size == BUFFER_SIZE) { pthread_cond_wait(&(q->full), &(q->mutex)); } q->buffer[q->in] = val; q->in = (q->in + 1) % BUFFER_SIZE; q->size++; pthread_cond_signal(&(q->empty)); pthread_mutex_unlock(&(q->mutex)); } int consume(Queue* q) { pthread_mutex_lock(&(q->mutex)); while (q->size == 0) { pthread_cond_wait(&(q->empty), &(q->mutex)); } int val = q->buffer[q->out]; q->out = (q->out + 1) % BUFFER_SIZE; q->size--; pthread_cond_signal(&(q->full)); pthread_mutex_unlock(&(q->mutex)); return val; } void* producer(void* arg) { Queue* q = (Queue*)arg; for (int i = 1; i <= 10; i++) { produce(q, i); printf("Produced: %d\n", i); } pthread_exit(NULL); } void* consumer(void* arg) { Queue* q = (Queue*)arg; for (int i = 1; i <= 10; i++) { int val = consume(q); printf("Consumed: %d\n", val); } pthread_exit(NULL); } int main() { Queue q; q.size = 0; q.in = 0; q.out = 0; pthread_mutex_init(&(q.mutex), NULL); pthread_cond_init(&(q.full), NULL); pthread_cond_init(&(q.empty), NULL); pthread_t producer_thread, consumer_thread; pthread_create(&producer_thread, NULL, producer, (void*)(&q)); pthread_create(&consumer_thread, NULL, consumer, (void*)(&q)); pthread_join(producer_thread, NULL); pthread_join(consumer_thread, NULL); pthread_cond_destroy(&(q.full)); pthread_cond_destroy(&(q.empty)); pthread_mutex_destroy(&(q.mutex)); return 0; } ``` 该示例中,我们定义了一个用于线程间共享的队列结构体,并使用互斥锁(`mutex`)和条件变量(`full`和`empty`)保证了生产者与消费者之间的同步。生产者通过`produce`函数将数据存入队列中,如果队列已满,则阻塞等待直到有空间可用。消费者通过`consume`函数从队列中取出数据,如果队列为空,则阻塞等待直到有数据可用。在`main`函数中创建了一个生产者线程和一个消费者线程,并使用`pthread_join`函数等待线程执行结束。 该示例中,生产者线程会依次将数值1~10存入队列中,消费者线程会依次从队列中取出数值并打印。通过互斥锁和条件变量的使用,保证了生产者与消费者之间的正确同步,避免了生产者在队列已满时继续生产以及消费者在队列为空时继续消费的问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值