### 回答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存入
队列中，
消费者线程会依次从
队列中取出数值并打印。通过互斥锁和条件变量的使用，保证了
生产者与
消费者之间的正确同步，避免了
生产者在
队列已满时继续生产以及
消费者在
队列为空时继续消费的问题。
扫一扫
375
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
