为什么单链表的Next（）操作应由关键部分保护？

Question

我正在阅读Win32中的《 多线程应用程序 》一书

该书说， return node->next将被编译成单独的机器指令，这些指令不会作为原子操作执行，因此Next()也应由关键部分保护。

我的问题是，它会被翻译成什么指令以引起比赛状况？

typedef struct _Node
{
    struct Node *next;
    int data;
} Node;

typedef struct _List
{
    Node *head;
    CRITICAL SECTION critical_sec;
} List;

List *CreateList()
{
    List *pList = malloc(sizeof(List));
    pList->head = NULL;
    InitializeCriticalSection(&pList->critical_sec);
    return pList;
}

void DeleteList(List *pList)
{
    DeleteCriticalSection(&pList->critical_sec);
    free(pList);
}

void AddHead(List *pList, Node *node)
{
    EnterCriticalSection(&pList->critical_sec);
    node->next = pList->head;
    pList->head = node;
    LeaveCriticalSection(&pList->critical_sec);
}

void Insert(List *pList, Node *afterNode, Node *newNode)
{
    EnterCriticalSection(&pList->critical_sec);
    if (afterNode == NULL)
    {
        AddHead(pList, newNode);
    }
    else
    {
        newNode->next = afterNode->next;
        afterNode->next = newNode;
    }
    LeaveCriticalSection(&pList->critical_sec);
}

Node *Next(List *pList, Node *node)
{
    Node* next;
    EnterCriticalSection(&pList->critical_sec);
    next = node->next;
    LeaveCriticalSection(&pList->critical_sec);
    return next;
}

编辑：

好的，尽管在这种特殊情况下它不会破坏单个链表而不保护Next()操作，但是共享结构应该整体上受到保护，或者一无所获。

Answer 1

return node->next执行两项操作； 它首先将node指向的struct加载到内存中，然后查看node+offsetof(next)以查找next指针，将其加载到寄存器中，然后返回到调用程序。 同时， node的内容可能会被另一个执行线程操纵。

Answer 2

1. 是的，您绝对需要在多线程应用程序中使用锁来保护“下一个”。

...但是...

1. “作家”（如添加或删除节点） 必须互斥。 关键部分是一个不错的选择。

2. “读者”（例如“下一个”）可以彼此并发运行。

建议：

如果可以使用Windows Vista或更高版本，请考虑使用SRW锁：

• http://msdn.microsoft.com/en-us/library/aa904937%28VS.85%29.aspx

• http://msdn.microsoft.com/en-us/magazine/cc163405.aspx

Answer 3

虽然我认为sarnold的答案是正确的，但我只是想指出，CreateList中malloc（）调用中的sizeof（）调用似乎有一个错误。 我相信它应该是：

List *pList = malloc(sizeof(List));

按照这种方式，您将创建足够的内存来保存指向 List而不是List结构的指针 。 （您可能还希望将返回类型强制转换为（List *）并将其与NULL比较，然后再使用。）