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

我在Qt的源代码中看到了一些x86程序集：

q_atomic_increment:
    movl 4(%esp), %ecx
    lock 
    incl (%ecx)
    mov $0,%eax
    setne %al
    ret

    .align 4,0x90
    .type q_atomic_increment,@function
    .size   q_atomic_increment,.-q_atomic_increment

1. 从谷歌搜索，我知道lock指令将导致CPU锁定总线，但是我不知道CPU何时释放总线？

2. 关于上面的整个代码，我不明白该代码如何实现Add？

1. LOCK本身不是指令：它是指令前缀，适用于以下指令。该指令必须的东西做内存（读-修改-写INC，XCHG，CMPXCHG等）---在这种情况下它是incl (%ecx)哪个指令increments的l在举行的地址翁字ecx寄存器。

   该LOCK前缀可确保CPU具有操作的持续时间适当的高速缓存线的独占所有权，并提供某些额外订购的保证。这可以通过声明总线锁定来实现，但是CPU会尽可能避免这种情况。如果总线被锁定，则仅在锁定指令期间。

2. 此代码将要从堆栈中递增的变量的地址复制到ecx寄存器中，然后lock incl (%ecx)通过原子方式将该变量递增1。接下来的两条指令将eax寄存器（保存函数的返回值）设置为0，如果变量的新值是0，否则为1。该操作是一个增量，而不是一个加法（因此而得名）。

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

Lock关键字强制实际发生的多个微指令似乎是原子操作的。

如果您有2个线程分别尝试递增相同的变量，并且它们都同时读取相同的原始值，那么它们都将递增至相同的值，并且都写出相同的值。

您不必将变量递增两次（这是通常的期望），而是最终将变量递增一次。

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

从谷歌，我知道锁定指令将导致CPU锁定总线，但我不知道何时CPU释放总线？

LOCK是指令的前缀，因此仅适用于以下指令，此处的源代码并不清楚，但实际的指令是LOCK INC。因此，将总线锁定为增量，然后将其解锁

关于以上整个代码，我不了解这些代码如何实现Add？

他们没有实现加法，而是实现了增量，以及如果旧值是0，则实现了返回指示。将使用加法LOCK XADD（但是，也可以使用实现Windows InterlockedIncrement / Decrement LOCK XADD）。

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

main.cpp

#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上游。

编译并运行：

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中启动线程？

另请参阅：多核汇编语言是什么样的？

在Ubuntu 19.04 amd64中测试。