使用C++11编写一个无锁队列

由于无锁队列是一个涉及到多线程并发操作的数据结构，需要使用原子操作来保证线程安全。下面是一个使用C11编写的无锁队列的实现：

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

#define CACHE_LINE_SIZE 64

typedef struct queue_node queue_node_t;

struct queue_node {
    queue_node_t* next;
    void* value;
};

typedef struct queue {
    queue_node_t* head;
    queue_node_t* tail;
    char padding[CACHE_LINE_SIZE - sizeof(queue_node_t*) * 2];
} queue_t;

void queue_init(queue_t* queue) {
    queue_node_t* dummy_node = (queue_node_t*) malloc(sizeof(queue_node_t));
    dummy_node->next = NULL;
    dummy_node->value = NULL;
    queue->head = dummy_node;
    queue->tail = dummy_node;
}

bool queue_is_empty(queue_t* queue) {
    return (queue->head == queue->tail);
}

void queue_enqueue(queue_t* queue, void* value) {
    queue_node_t* node = (queue_node_t*) malloc(sizeof(queue_node_t));
    node->next = NULL;
    node->value = value;
    queue_node_t* prev_tail = atomic_exchange(&queue->tail, node);
    prev_tail->next = node;
}

void* queue_dequeue(queue_t* queue) {
    queue_node_t* head = queue->head;
    queue_node_t* next = head->next;
    if (next == NULL) {
        return NULL;
    }
    void* value = next->value;
    queue->head = next;
    free(head);
    return value;
}

在这个实现中，我们使用了`atomic_exchange`原子操作来保证对队列尾部的修改是原子的。同时，我们也使用了内存对齐来避免不必要的缓存行争用。