Question

为了提高我的C语言技能，我实现了一个线程安全且无锁的队列。该算法摘自Maurice Herlihy和Nir Shavit所著的“多处理器编程的艺术”一书的第10.5章，这是一本很棒的书。

到目前为止，一切正常，但是我需要以下问题的帮助：

问题

在free(first)方法中将行lfq_deq()注释掉，因为如果队列被多个出队者使用，则可能导致段错误。如果线程T1和T2出队，并且T1释放了节点，而T2仍在使用它，则T2将产生段错误。

释放此内存的一种优雅方法是什么？因为我不重用节点，所以我不应该遇到ABA问题，对吗？还是您认为，重用节点并为ABA问题实施已知的解决方案会更容易？

lfq.h

标头提供了一种简单的主要测试方法。

#pragma once
#include <stdlib.h>

typedef struct Node {
    void* data;
    struct Node* next;
} lfq_node_t;

typedef struct Queue {
    lfq_node_t* head;
    lfq_node_t* tail;
} lfq_t;

lfq_t* lfq_new();
void lfq_free(lfq_t* q);
void lfq_enq(lfq_t* q, void* data);
void* lfq_deq(lfq_t* q);

lfq.c

#include "lfq.h"
#include <pthread.h>
#include <stdio.h>

#define CAS(a, b, c) __sync_bool_compare_and_swap(a, b, c)

lfq_t* lfq_new() {
    lfq_t* q = malloc(sizeof(*q));
    lfq_node_t* sentinel = malloc(sizeof(*sentinel));
    sentinel->data = sentinel->next = NULL;
    q->head = q->tail = sentinel;

    return q;
}

void lfq_free(lfq_t* q) {
    lfq_node_t *next, *node = q->head;
    while (node != NULL) {
        next = node->next;
        free(node);
        node = next;
    }
    free(q);
}

void lfq_enq(lfq_t* q, void* data) {
    lfq_node_t *node, *last, *next;

    node = malloc(sizeof(*node));
    node->data = data;
    node->next = NULL;

    while (1) {
        last = q->tail;
        next = last->next;
        if (last == q->tail) {
            if (next == NULL) {
                if (CAS(&(last->next), next, node)) {
                    CAS(&(q->tail), last, node);
                    return;
                }
            } else {
                CAS(&(q->tail), last, next);
            }
        }
    }
}

void* lfq_deq(lfq_t* q) {
    lfq_node_t *first, *last, *next;
    while (1) {
        first = q->head;
        last = q->tail;
        next = first->next;

        if (first == q->head) {
            if (first == last) {
                if (next == NULL) return NULL;
                CAS(&(q->tail), last, next);
            } else {
                void* data = first->next->data;
                if (CAS(&(q->head), first, next)) {
                    // free(first);
                    return data;
                }
            }
        }
    }
}

main.c

一种简单的测试队列的主要方法：

#include "lfq.h"
#include <stdio.h>

int main() {
    int values[] = {1, 2, 3, 4, 5};
    lfq_t* q = lfq_new();
    for (int i = 0; i < 5; ++i) {
        printf("ENQ %i\n", values[i]);
        lfq_enq(q, &values[i]);
    }
    for (int i = 0; i < 5; ++i) printf("DEQ %i\n", *(int*)lfq_deq(q));
    lfq_free(q);
    return 0;
}

Answer 1

这就像迈克尔和斯科特的队伍。

无法释放节点，我不记得确切的原因（显然是因为仍然可以引用它们-但确切地说，我忘记了哪里和如何）。它们只能放置在空闲列表中。

我没有仔细检查您的实现是否正确，但是我看到没有内存障碍，这意味着实现是错误的。

您需要发现并阅读并理解内存障碍，然后使用它们。

我写了两篇文章，可以帮助您入门。

https://www.liblfds.org/mediawiki/index.php?title=Article:Memory_Barriers_%28part_1%29

https://www.liblfds.org/mediawiki/index.php?title=Article:Memory_Barriers_%28part_2%29

Answer 2

正如Peter Cordes在他的评论中指出的，我刚刚发现了内存回收问题：

相比之下，内存回收是无锁数据结构设计最具挑战性的方面之一。无锁算法（也称为非阻塞算法）确保只要某些进程继续采取步骤，最终某个进程将完成操作。对无锁数据结构执行内存回收的主要困难是，在保持指向将要释放的对象的指针的同时，进程可能正在休眠。因此，不小心释放对象可能会导致睡眠过程在唤醒时导致睡眠过程访问释放的内存，从而使程序崩溃或产生微妙的错误。由于未锁定节点，因此进程必须进行协调，以使彼此知道哪些节点可以安全回收，哪些仍然可以访问。

引自奥地利科学技术研究所特雷弗·布朗（Trevor Brown）的“回收无锁数据结构的内存：必须有更好的方法”

here找到了一个很好的答案（与堆栈有关，但本质上是相同的）。

C无锁队列内存管理

问题

lfq.h

lfq.c

main.c

2 个答案: