c++11 原子<int> ++ 比 std::mutex protected int++ 慢得多，为什么？</int>

Question

为了比较std::atomic<int> ++ 和std::mutex protected int ++ 之间的性能差异，我有这个测试程序：

#include <iostream>
#include <atomic>
#include <mutex>
#include <thread>
#include <chrono>
#include <limits>
using namespace std;
#ifndef INT_MAX
const int INT_MAX = numeric_limits<std::int32_t>::max();
const int INT_MIN = numeric_limits<std::int32_t>::min();
#endif
using std::chrono::steady_clock;
const size_t LOOP_COUNT = 12500000;
const size_t THREAD_COUNT = 8;
int intArray[2] = { 0, INT_MAX };
atomic<int> atomicArray[2];
void atomic_tf() {//3.19s
    for (size_t i = 0; i < LOOP_COUNT; ++i) {
        atomicArray[0]++;
        atomicArray[1]--;
    }
}
mutex m;
void mutex_tf() {//0.25s
    m.lock();
    for (size_t i = 0; i < LOOP_COUNT; ++i) {
        intArray[0]++;
        intArray[1]--;
    }
    m.unlock();
}
int main() {
    {
        atomicArray[0] = 0;
        atomicArray[1] = INT_MAX;
        thread tp[THREAD_COUNT];
        steady_clock::time_point t1 = steady_clock::now();
        for (size_t t = 0; t < THREAD_COUNT; ++t) {
            tp[t] = thread(atomic_tf);
        }
        for (size_t t = 0; t < THREAD_COUNT; ++t) {
            tp[t].join();
        }
        steady_clock::time_point t2 = steady_clock::now();
        cout << (float)((t2 - t1).count()) / 1000000000 << endl;
    }
    {
        thread tp[THREAD_COUNT];
        steady_clock::time_point t1 = steady_clock::now();
        for (size_t t = 0; t < THREAD_COUNT; ++t) {
            tp[t] = thread(mutex_tf);
        }
        for (size_t t = 0; t < THREAD_COUNT; ++t) {
            tp[t].join();
        }
        steady_clock::time_point t2 = steady_clock::now();
        cout << (float)((t2 - t1).count()) / 1000000000 << endl;
    }
    return 0;
}

我在windows/linux上多次运行这个程序（用clang++14、g++12编译），结果基本相同。

1. atomic_tf将需要 3 秒以上

2. mutex_tf将花费 0.25+ 秒。

几乎10倍的性能差异。

我的问题是，如果我的测试程序是有效的，那么它是否表明使用原子变量比使用互斥锁 + 普通变量要贵得多？

这种性能差异是怎么来的？ 谢谢！

Answer 1

您的互斥锁版本将互斥锁锁定一次，然后进行12500000次迭代，而无需为线程同步机制支付任何额外费用。

在您的原子版本中，您为每次递增和每次递减原子值（每次发生12500000次）支付原子同步的成本。

因此，您的测试并没有真正比较mutex 与 atomic的性能。

如果您想这样做，您可以尝试在值的每次递增或递减时锁定和解锁互斥锁。

就像是：

void mutex_tf() 
{
    for (size_t i = 0; i < LOOP_COUNT; ++i) 
    {
        m.lock();
        intArray[0]++;
        m.unlock(); 

        m.lock();
        intArray[1]--;
        m.unlock(); 
    }
}