无锁队列

cas:

bool compare_and_swap(int* ret, int oldval, int newval)
{
    if (*ret == oldval) {
        *ret = newval;
        return true;
    }
    return false;
}

gcc cas:

bool __sync_bool_compare_and_swap(int* ,int, int);

lock free queue:

#include <iostream>
#include <stdlib.h>

using namespace std;

struct node {
    int val;
    node* next;
};

struct List {
    node* head;
    node* tail;
};

void init(List* l)
{
    l->head = l->tail = (node*)malloc(sizeof(node));
    l->head->next = nullptr;
}

void cas_push(List* l, int val)
{
    node* tmp = new node;
    tmp->val = val;
    tmp->next = nullptr;
    node* ptr;
    do {
        ptr = l->tail;
    } while (!__sync_bool_compare_and_swap((int*)(&(ptr->next)), NULL, (long)tmp));
    l->tail = tmp;
}

bool isEmpty(List* l)
{
    if (l->head->next == NULL) {
        return true;
    }
    return false;
}

int pop(List* l)
{
    if (isEmpty(l)) {
        throw "list is empty";
    }
    node* tmp = l->head->next;
    l->head->next = tmp->next;
    free(tmp);
    return 0;
}

int cas_pop(List* l)
{
    node* tmp;
    do {
        if (isEmpty(l)) {
            throw "list is empty";
        }
        tmp = l->head->next;
    } while (!__sync_bool_compare_and_swap((int*)&(l->head->next), (long)tmp, (long)tmp->next));
    int val = tmp->val;
    free(tmp);
    return val;
}

int main()
{
    List* l = (List*)malloc(sizeof(List));
    init(l);
    List* ll = l;
    for (int i = 0; i < 10; i++) {
        cas_push(l, i);
    }
    //cout << ll->head->val << endl;
    if (isEmpty(ll)) {
        cout << "e" << endl;
    }
    for (int i = 0; i < 11; i++) {
        try {
            cout << cas_pop(ll) << endl;
        } catch (const char* e) {
            cout << e << endl;
        }
    }
}