c++：自旋锁或互斥量比较（简单计算）

Question

对于简单任务，自旋锁应该比互斥锁具有更好的性能。然而，在这个简单的测试（8 个线程递增计数器）中，结果显示不同：

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

using namespace std;

class SpinLock {
private:
    atomic_flag lck = ATOMIC_FLAG_INIT;
public:
    void lock() { while(lck.test_and_set(memory_order_acquire)) {} }
    void unlock() { lck.clear(memory_order_release); }
};

int total = 0;

#ifdef SPINLOCK
SpinLock my_lock;
#else
mutex my_lock;
#endif

void foo(int n)
{
    for(int i = 0; i < 10000000; ++i) {
#ifdef SPINLOCK
        lock_guard<SpinLock> lck(my_lock);
#else
        lock_guard<mutex> lck(my_lock);
#endif
        ++total;
    }
}

int main()
{
    vector<thread> v;

    for(int i = 0; i < 8; ++i)
        v.emplace_back(foo, i);

    for(auto& t : v)
        t.join();

    cout << "total: " << total << endl;
    return 0;
}

测试自旋锁：

$ g++ -DSPINLOCK -std=c++11 -Wall -pthread test.cc
$ time ./a.out
total: 80000000
real    0m18.206s
user    2m17.792s
sys     0m0.003s

测试互斥体：

$ g++ -std=c++11 -Wall -pthread test.cc
$ time ./a.out
total: 80000000
real    0m9.483s
user    0m6.451s
sys     1m6.043s

结果表明互斥锁几乎比自旋锁快两倍。自旋锁大部分时间花在“user cpu”上，互斥锁大部分时间花在“sys cpu”上。互斥锁是如何实现的？在这样的简单计算中我应该使用互斥锁而不是自旋锁吗？谁能解释一下结果？

g++ 是 4.8.2，操作系统是 Red Hat Enterprise Linux 7。

谢谢。

Answer 1

一些注意事项：

1. 实用程序输出中显示的时间time是线程正在使用的 CPU 时间，而不是实际时间。自旋锁即使在等待期间也会使用 cpu，而内核互斥体将在等待时执行其他进程中的其他线程，不会对您的进程收取该 CPU 时间的费用，除了用于实际执行调度的时间（您在互斥体情况下的 sys 行中看到的那个） ）。

2. 出于与上述相同的原因，在自旋锁情况下，从进程开始到结束所需等待的总时间可能会更快，但是您的 cpu 可能有更高的使用率，这就是您所观察到的。

3. 如果冲突机会较低，线程可能是一个不错的选择，也就是说，与异步加载相比，线程在同步加载上花费的时间很小。如果您的所有负载都受到互斥体的保护，则只有使用线程的开销 - 您可能应该将其序列化。

如果碰撞机会低并且碰撞时等待时间短，那么自旋锁是很好的选择。在您的情况下，您有 8 个线程与同一资源发生冲突，然后要求资源在您释放后立即可用。这意味着平均有 1 个线程在工作，其他 7 个自旋锁，使用的总 CPU 时间是单线程所需时间的 8 倍（如果你有一台 8 核机器并且没有其他负载）。在互斥锁的情况下，线程会在资源可用时暂停并唤醒，因此没有等待的开销，但是锁定互斥锁将需要一些开销，因为在内核中需要做一些工作来跟踪哪些进程正在等待互斥锁，即使它不是太大，您也会执行 1.6 亿次互斥操作，这总计为sys您的进程计费的时间