How do I implement a lock-free queue in C?

How do I implement a lock-free queue in C?

To implement a lock-free queue in C, you can use atomic operations and a linked list structure. Would you like a code example?

Yes, please provide a code example.

Here's a simple implementation using atomic pointers:

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

typedef struct Node {
    int value;
    struct Node* next;
} Node;

typedef struct Queue {
    atomic_intptr_t head;
    atomic_intptr_t tail;
} Queue;

Queue* createQueue() {
    Queue* q = malloc(sizeof(Queue));
    Node* dummy = malloc(sizeof(Node));
    dummy->next = NULL;
    atomic_store(&q->head, (intptr_t)dummy);
    atomic_store(&q->tail, (intptr_t)dummy);
    return q;
}

void enqueue(Queue* q, int value) {
    Node* newNode = malloc(sizeof(Node));
    newNode->value = value;
    newNode->next = NULL;
    Node* oldTail;
    while (1) {
        oldTail = (Node*)atomic_load(&q->tail);
        Node* next = oldTail->next;
        if (next == NULL) {
            if (atomic_compare_exchange_weak(&oldTail->next, &next, newNode)) {
                atomic_compare_exchange_weak(&q->tail, &oldTail, newNode);
                return;
            }
        } else {
            atomic_compare_exchange_weak(&q->tail, &oldTail, next);
        }
    }
}

int dequeue(Queue* q) {
    Node* oldHead;
    while (1) {
        oldHead = (Node*)atomic_load(&q->head);
        Node* oldTail = (Node*)atomic_load(&q->tail);
        Node* next = oldHead->next;
        if (oldHead == oldTail) {
            if (next == NULL) {
                return -1; // Queue is empty
            }
            atomic_compare_exchange_weak(&q->tail, &oldTail, next);
        } else {
            int value = next->value;
            if (atomic_compare_exchange_weak(&q->head, &oldHead, next)) {
                free(oldHead);
                return value;
            }
        }
    }
}

What are the advantages of using a lock-free queue?

Lock-free queues can improve performance by reducing contention and avoiding deadlocks, making them suitable for high-concurrency environments.