現象：

（1）單執行緒無鎖速度最快，但應用場合受限；

（2）多執行緒無鎖速度第二快，但結果不對，未保護臨界程式碼段；

（3）多執行緒原子鎖第三快，且結果正確；

（4）多執行緒互斥量較慢，慢與原子鎖近10倍，結果正確；

（5）多執行緒自旋鎖最慢，慢與原子鎖30倍，結果正確。

結論：原子鎖速度最快，互斥量和自旋鎖都用保護多執行緒共享資源。

       自旋鎖是一種非阻塞鎖，也就是說，如果某執行緒需要獲取自旋鎖，但該鎖已經被其他執行緒佔用時，該執行緒不會被掛起，而是在不斷的消耗CPU的時間，不停的試圖獲取自旋鎖。
       互斥量是阻塞鎖，當某執行緒無法獲取互斥量時，該執行緒會被直接掛起，該執行緒不再消耗CPU時間，當其他執行緒釋放互斥量後，作業系統會啟用那個被掛起的執行緒，讓其投入執行。

       在多處理器環境中對持有鎖時間較短的程式來說使用自旋鎖代替一般的互斥鎖往往能提高程式的效能，但是本程式碼無該效果。

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

class spin_mutex {
    std::atomic<bool> flag = ATOMIC_VAR_INIT(false);
public:
    spin_mutex() = default;
    spin_mutex(const spin_mutex&) = delete;
    spin_mutex& operator= (const spin_mutex&) = delete;
    void lock() {
        bool expected = false;
        while (!flag.compare_exchange_strong(expected, true))
            expected = false;
    }
    void unlock() {
        flag.store(false);
    }
};

long size = 1000000;
long total = 0;
std::atomic_long total2(0);
std::mutex m;
spin_mutex lock;

void thread_click()
{
    for (int i = 0; i < size; ++i)
    {
        ++total;
    }
}

void mutex_click()
{
    for (int i = 0; i < size; ++i)
    {
        m.lock();
        ++total;
        m.unlock();
    }
}

void atomic_click()
{
    for (int i = 0; i < size; ++i)
    {
        ++total2;
    }
}


void spinlock_click()
{
    for (int i = 0; i < size; ++i)
    {
        lock.lock();
        ++total;
        lock.unlock();
    }
}

int main()
{
    int thnum = 100;
    std::vector<std::thread> threads(thnum);
    clock_t start, end;

    total = 0;
    start = clock();
    for (int i = 0; i < size * thnum; i++) {
        ++total;
    }
    end = clock();
    std::cout << "single thread result: " << total << std::endl;
    std::cout << "single thread time: " << end - start << std::endl;

    total = 0;
    start = clock();
    for (int i = 0; i < thnum; ++i) {
        threads[i] = std::thread(thread_click);
    }
    for (int i = 0; i < thnum; ++i) {
        threads[i].join();
    }
    end = clock();
    std::cout << "multi thread no mutex result: " << total << std::endl;
    std::cout << "multi thread no mutex time: " << end - start << std::endl;

    total = 0;
    start = clock();
    for (int i = 0; i < thnum; ++i) {
        threads[i] = std::thread(atomic_click);
    }
    for (int i = 0; i < thnum; ++i) {
        threads[i].join();
    }
    end = clock();
    std::cout << "multi thread atomic result: " << total2 << std::endl;
    std::cout << "multi thread atomic time: " << end - start << std::endl;

    total = 0;
    start = clock();
    for (int i = 0; i < thnum; ++i) {
        threads[i] = std::thread(mutex_click);
    }
    for (int i = 0; i < thnum; ++i) {
        threads[i].join();
    }
    end = clock();
    std::cout << "multi thread mutex result: " << total << std::endl;
    std::cout << "multi thread mutex time: " << end - start << std::endl;

    total = 0;
    start = clock();
    for (int i = 0; i < thnum; ++i) {
        threads[i] = std::thread(spinlock_click);
    }
    for (int i = 0; i < thnum; ++i) {
        threads[i].join();
    }
    end = clock();
    std::cout << "spin lock result: " << total << std::endl;
    std::cout << "spin lock time: " << end - start << std::endl;
    getchar();
    return 0;
}

/*
single thread result: 100000000
single thread time: 231
multi thread no mutex result: 11501106
multi thread no mutex time: 261
multi thread atomic result: 100000000
multi thread atomic time: 1882
multi thread mutex result: 100000000
multi thread mutex time: 16882
spin lock result: 100000000
spin lock time: 45063
*/