下面是一个使用
C语言线程邮箱的代码示例：
```c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#define QUEUE_SIZE 10
// 队列结构体定义
typedef struct {
int data[QUEUE_SIZE];
int front;
int rear;
pthread_mutex_t lock;
pthread_cond_t not_empty;
pthread_cond_t not_full;
} Queue;
// 初始化队列
void initQueue(Queue *q) {
q->front = 0;
q->rear = 0;
pthread_mutex_init(&q->lock, NULL);
pthread_cond_init(&q->not_empty, NULL);
pthread_cond_init(&q->not_full, NULL);
}
// 判断队列是否已满
int isQueueFull(Queue *q) {
return ((q->rear + 1) % QUEUE_SIZE == q->front);
}
// 判断队列是否为空
int isQueueEmpty(Queue *q) {
return (q->front == q->rear);
}
// 入队
int enQueue(Queue *q, int data) {
pthread_mutex_lock(&q->lock);
while (isQueueFull(q)) {
// 如果队列已满，等待
pthread_cond_wait(&q->not_full, &q->lock);
}
q->data[q->rear] = data;
q->rear = (q->rear + 1) % QUEUE_SIZE;
pthread_cond_signal(&q->not_empty);
pthread_mutex_unlock(&q->lock);
return 0;
}
// 出队
int deQueue(Queue *q, int *data) {
pthread_mutex_lock(&q->lock);
while (isQueueEmpty(q)) {
// 如果队列为空，等待
pthread_cond_wait(&q->not_empty, &q->lock);
}
*data = q->data[q->front];
q->front = (q->front + 1) % QUEUE_SIZE;
pthread_cond_signal(&q->not_full);
pthread_mutex_unlock(&q->lock);
return 0;
}
// 生产者
线程函数
void* producer(void *arg) {
Queue *q = (Queue*)arg;
int i;
for (i = 0; i < 20; i++) {
enQueue(q, i);
printf("Producer: %d\n", i);
}
return NULL;
}
// 消费者
线程函数
void* consumer(void *arg) {
Queue *q = (Queue*)arg;
int data;
while (1) {
deQueue(q, &data);
printf("Consumer: %d\n", data);
}
return NULL;
}
int main() {
Queue q;
initQueue(&q);
pthread_t prod_tid, cons_tid;
pthread_create(&prod_tid, NULL, producer, &q);
pthread_create(&cons_tid, NULL, consumer, &q);
pthread_join(prod_tid, NULL);
pthread_join(cons_tid, NULL);
return 0;
}
```
在以上代码中，我们使用了
线程安全的队列结构体，并使用互斥锁和条件变量来实现
线程同步。在生产者
线程函数中，我们不断向队列中写入数据，如果队列已满，则等待条件变量 `not_full`；在消费者
线程函数中，我们不断从队列中读取数据，如果队列已空，则等待条件变量 `not_empty`。
在主函数中，我们创建了一个生产者
线程和一个消费者
线程，并分别传入队列结构体的指针作为参数。最后，我们使用 `pthread_join` 函数等待两个子
线程结束。
扫一扫
1471
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
