C语言消息队列示例

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

// 定义消息结构体
typedef struct Message {
    int data; // 消息内容，这里以整数为例
    struct Message* next;
} Message;

// 定义消息队列结构体
typedef struct MessageQueue {
    Message* head; // 队列头部
    Message* tail; // 队列尾部
    pthread_mutex_t lock; // 互斥锁
} MessageQueue;

// 初始化消息队列
void initMessageQueue(MessageQueue* queue) {
    queue->head = NULL;
    queue->tail = NULL;
    pthread_mutex_init(&queue->lock, NULL); // 初始化互斥锁
}

// 向消息队列中添加消息
void enqueueMessage(MessageQueue* queue, int data) {
    pthread_mutex_lock(&queue->lock); // 加锁

    Message* newMessage = (Message*)malloc(sizeof(Message));
    if (newMessage == NULL) {
        fprintf(stderr, "内存分配失败\n");
        pthread_mutex_unlock(&queue->lock); // 解锁
        return;
    }
    newMessage->data = data;
    newMessage->next = NULL;

    if (queue->tail == NULL) {
        queue->head = newMessage;
        queue->tail = newMessage;
    } else {
        queue->tail->next = newMessage;
        queue->tail = newMessage;
    }

    pthread_mutex_unlock(&queue->lock); // 解锁
}

// 从消息队列中获取并移除消息
int dequeueMessage(MessageQueue* queue) {
    pthread_mutex_lock(&queue->lock); // 加锁

    if (queue->head == NULL) {
        pthread_mutex_unlock(&queue->lock); // 解锁
        fprintf(stderr, "队列为空\n");
        return -1; // 返回一个错误码
    }

    Message* temp = queue->head;
    int data = temp->data;

    queue->head = queue->head->next;
    if (queue->head == NULL) {
        queue->tail = NULL;
    }

    free(temp);

    pthread_mutex_unlock(&queue->lock); // 解锁
    return data;
}

// 检查消息队列是否为空
int isQueueEmpty(MessageQueue* queue) {
    pthread_mutex_lock(&queue->lock); // 加锁
    int isEmpty = (queue->head == NULL);
    pthread_mutex_unlock(&queue->lock); // 解锁
    return isEmpty;
}

// 销毁消息队列
void destroyMessageQueue(MessageQueue* queue) {
    pthread_mutex_lock(&queue->lock); // 加锁

    while (queue->head != NULL) {
        Message* temp = queue->head;
        queue->head = queue->head->next;
        free(temp);
    }

    pthread_mutex_unlock(&queue->lock); // 解锁
    pthread_mutex_destroy(&queue->lock); // 销毁互斥锁
}

// 生产者线程函数
void* producer(void* arg) {
    MessageQueue* queue = (MessageQueue*)arg;
    for (int i = 0; i < 10; i++) {
        enqueueMessage(queue, i);
        printf("生产者线程添加消息: %d\n", i);
        sleep(1); // 模拟生产时间
    }
    return NULL;
}

// 消费者线程函数
void* consumer(void* arg) {
    MessageQueue* queue = (MessageQueue*)arg;
    while (1) {
        int data = dequeueMessage(queue);
        if (data == -1) {
            break; // 队列为空，退出循环
        }
        printf("消费者线程获取消息: %d\n", data);
        sleep(1); // 模拟消费时间
    }
    return NULL;
}

int main() {
    MessageQueue queue;
    initMessageQueue(&queue);

    pthread_t producerThread, consumerThread;

    // 创建生产者和消费者线程
    pthread_create(&producerThread, NULL, producer, &queue);
    pthread_create(&consumerThread, NULL, consumer, &queue);

    // 等待线程结束
    pthread_join(producerThread, NULL);
    pthread_join(consumerThread, NULL);

    // 销毁消息队列
    destroyMessageQueue(&queue);

    return 0;
}