无锁循环队列

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <stdatomic.h>

// 定义数据类型
typedef int ElemType;

// 定义循环队列类
typedef struct {
    ElemType *elems;    // 存储队列元素的指针
    _Atomic int front;  // 队首指针
    _Atomic int rear;   // 队尾指针
    _Atomic int count;  // 队列中元素的个数
    int max_count;      // 队列最大容量
} CircleQueue;

// 初始化循环队列
void initQueue(CircleQueue *q, int max_count) {
    q->elems = (ElemType *)malloc(max_count * sizeof(ElemType));
    atomic_init(&q->front, 0);
    atomic_init(&q->rear, 0);
    atomic_init(&q->count, 0);
    q->max_count = max_count;
}

// 销毁循环队列
void destroyQueue(CircleQueue *q) {
    free(q->elems);
    atomic_store(&q->front, 0);
    atomic_store(&q->rear, 0);
    atomic_store(&q->count, 0);
    q->max_count = 0;
}

// 判断队列是否为空
bool isEmpty(CircleQueue *q) {
    return atomic_load(&q->count) == 0;
}

// 判断队列是否已满
bool isFull(CircleQueue *q) {
    return atomic_load(&q->count) == q->max_count;
}

// 入队操作
bool enqueue(CircleQueue *q, ElemType e) {
    if (isFull(q)) {
        printf("队列已满，无法入队！\n");
        return false;
    }
    int rear = atomic_load(&q->rear);
    q->elems[rear] = e;
    atomic_store(&q->rear, (rear + 1) % q->max_count);
    atomic_fetch_add(&q->count, 1);
    return true;
}

// 出队操作
bool dequeue(CircleQueue *q, ElemType *e) {
    if (isEmpty(q)) {
        printf("队列为空，无法出队！\n");
        return false;
    }
    int front = atomic_load(&q->front);
    *e = q->elems[front];
    atomic_store(&q->front, (front + 1) % q->max_count);
    atomic_fetch_sub(&q->count, 1);
    return true;
}

// 测试循环队列的代码
int main() {
    CircleQueue q;
    int max_count = 5;  // 队列最大元素个数
    initQueue(&q, max_count);  // 初始化队列
    for (int i = 1; i <= max_count + 1; i++) {
        if (!enqueue(&q, i)) {
            printf("第%d个元素入队失败！\n", i);
        }
    }
    ElemType e;
    while (!isEmpty(&q)) {
        dequeue(&q, &e);
        printf("%d ", e);
    }
    printf("\n");
    destroyQueue(&q);  // 销毁队列
    return 0;
}