x86 汇编中的“锁定”指令是什么意思？

LOCK 本身不是指令：它是指令前缀，适用于后面的指令。该指令必须是对内存（INC、XCHG、CMPXCHG 等）执行读-修改-写操作的指令——在这种情况下，它是 incl (%ecx) 指令，它在ecx 寄存器。 LOCK 前缀确保 CPU 在操作期间拥有相应缓存行的独占所有权，并提供某些额外的排序保证。这可以通过断言总线锁定来实现，但 CPU 将尽可能避免这种情况。如果总线被锁定，则仅在锁定指令的持续时间内。此代码将要从堆栈中递增的变量的地址复制到 ecx 寄存器中，然后它会锁定 incl (%ecx) 以原子地将该变量递增 1。接下来的两条指令设置 eax 寄存器（它保存返回值如果变量的新值为 0，则为 0，否则为 1。该操作是增量，而不是添加（因此得名）。

---

您可能无法理解的是，增加一个值所需的微码要求我们首先读取旧值。

Lock 关键字强制实际发生的多条微指令以原子方式运行。

如果您有 2 个线程，每个线程都试图递增相同的变量，并且它们都同时读取相同的原始值，那么它们都会递增到相同的值，并且它们都写出相同的值。

不是让变量增加两次，这是典型的期望，而是最终增加一次变量。

lock 关键字可以防止这种情况发生。

---

从google，我知道lock指令会导致cpu锁定总线，但我不知道cpu什么时候释放总线？

LOCK是一个指令前缀，因此它只适用于后面的指令，来源在这里并没有说得很清楚，但真正的指令是LOCK INC。所以总线被锁定为增量，然后解锁

关于上面的整个代码，我不明白这些代码是如何实现 Add?

它们不实现添加，它们实现增量，以及如果旧值为 0 的返回指示。添加将使用 LOCK XADD（但是，Windows InterlockedIncrement/Decrement 也使用 LOCK XADD 实现）。

---

最小可运行 C++ 线程 + LOCK 内联汇编示例

主文件

#include <atomic>
#include <cassert>
#include <iostream>
#include <thread>
#include <vector>

std::atomic_ulong my_atomic_ulong(0);
unsigned long my_non_atomic_ulong = 0;
unsigned long my_arch_atomic_ulong = 0;
unsigned long my_arch_non_atomic_ulong = 0;
size_t niters;

void threadMain() {
    for (size_t i = 0; i < niters; ++i) {
        my_atomic_ulong++;
        my_non_atomic_ulong++;
        __asm__ __volatile__ (
            "incq %0;"
            : "+m" (my_arch_non_atomic_ulong)
            :
            :
        );
        __asm__ __volatile__ (
            "lock;"
            "incq %0;"
            : "+m" (my_arch_atomic_ulong)
            :
            :
        );
    }
}

int main(int argc, char **argv) {
    size_t nthreads;
    if (argc > 1) {
        nthreads = std::stoull(argv[1], NULL, 0);
    } else {
        nthreads = 2;
    }
    if (argc > 2) {
        niters = std::stoull(argv[2], NULL, 0);
    } else {
        niters = 10000;
    }
    std::vector<std::thread> threads(nthreads);
    for (size_t i = 0; i < nthreads; ++i)
        threads[i] = std::thread(threadMain);
    for (size_t i = 0; i < nthreads; ++i)
        threads[i].join();
    assert(my_atomic_ulong.load() == nthreads * niters);
    assert(my_atomic_ulong == my_atomic_ulong.load());
    std::cout << "my_non_atomic_ulong " << my_non_atomic_ulong << std::endl;
    assert(my_arch_atomic_ulong == nthreads * niters);
    std::cout << "my_arch_non_atomic_ulong " << my_arch_non_atomic_ulong << std::endl;
}

GitHub upstream。

编译并运行：

g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp -pthread
./main.out 2 10000

可能的输出：

my_non_atomic_ulong 15264
my_arch_non_atomic_ulong 15267

从这里我们看到 LOCK 前缀使添加原子：没有它，我们在许多添加上都有竞争条件，最后的总数小于同步的 20000。

LOCK前缀用于实现：

C++11 std::atomic：std::atomic 到底是什么？

C11 atomic_int：如何在纯 C 中启动线程？

另请参阅：What does multicore assembly language look like?

在 Ubuntu 19.04 amd64 中测试。

---