多线程使用CAS替换互斥锁

1. 不加锁，线程不安全

#include <chrono>
#include <iostream>
#include <thread>

using namespace std;
using namespace chrono;

int g_sum = 0;

void add(int num) {
    for (int i = 0; i < 10000000; i++) {
        g_sum += num;
    }
    return;
}
int main(int argc, char const *argv[]) {
    auto start = system_clock::now();
    std::thread t1(add, 1);
    std::thread t2(add, 1);
    t1.join();
    t2.join();
    std::cout << "sum:" << g_sum << std::endl;
    auto end = system_clock::now();
    auto duration = duration_cast<microseconds>(end - start);
    cout << "花费了"
         << double(duration.count()) * microseconds::period::num /
                microseconds::period::den
         << "秒" << endl;
    return 0;
}

输出，可以看出这块是线程不安全的，每次输出的数据都不一样

[root@localhost test-codes]# ./simple 
sum:10292677
花费了0.374036秒
[root@localhost test-codes]# ./simple 
sum:11729970
花费了0.417374秒
[root@localhost test-codes]# ./simple 
sum:14425458
花费了0.417321秒

2. 加锁来保证线程安全，耗时11s

std::mutex g_mutex;
void add(int num) {
    for (int i = 0; i < 10000000; i++) {
        std::lock_guard<std::mutex> guard(g_mutex);
        g_sum += num;
    }
    return;
}

[root@localhost test-codes]# ./simple 
sum:50000000
花费了11.5244秒
[root@localhost test-codes]# ./simple 
sum:50000000
花费了11.683秒
[root@localhost test-codes]# ./simple 
sum:50000000
花费了11.3936秒

3. 使用cas, 在保证正确的情况下，耗时较互斥锁时间短，8s左右

void add(int num) {
    int old_g_sum = g_sum;
    for (int i = 0; i < 10000000; i++) {
        while (
            !__sync_bool_compare_and_swap(&g_sum, old_g_sum, old_g_sum + 1)) {
            old_g_sum = g_sum;
        }
    }
    return;
}

[root@localhost test-codes]# ./simple 
sum:50000000
花费了7.90655秒
[root@localhost test-codes]# ./simple 
sum:50000000
花费了8.69977秒
[root@localhost test-codes]# ./simple 
sum:50000000
花费了8.88852秒

编译方式
g++ -std=c++11 -lpthread -march=nocona -mtune=generic simple.cpp -o simple
如果不加这俩参数，实际1和2差别不大。这俩参数扩展了编译性能。

如代码上面所示，其实CAS就是 compare and swap， 保留旧值，在写入新值之前，如果新值旧值相同(可以理解成上下文相同)则进行更新操作。

CAS是compare and swap, 简单来说就是，在写入新值之前， 读出旧值， 当且仅当旧值与存储中的当前值一致时，才把新值写入存储。是一种流行的无所算法，他只需要一步CPU指令，所以速度快。