1 原子操作

原子操作：一个独立不可分割的操作。多线程编程需要保证线程安全，而线程安全一个很重要的特性就是原子性，即在同一时刻只有一个线程对原子进行操作，保证数据访问的互斥性。

2 C++11原子变量

C++11提供了原子类型std::atomic，可以使用任意的类型作为模板参数。在多线程中如果使用了原子变量，其本身就保证了数据访问的互斥性，所以不需要使用互斥量来保护该变量了。

3 使用原子变量

3.1 没有使用线程互斥的数据操作

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

long long globalCount = 0;

void ThreadFunction()
{
    for (int i=0;i<100000;++i)
    {
        globalCount += 1;
    }
}

int main()
{
    std::vector<std::thread> threads;

    std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now();

    for (int i = 0; i < 10; ++i)
    {
        threads.push_back(std::thread(ThreadFunction));
    }

    for (int i=0;i<10;++i)
    {
        threads[i].join();
    }
    std::chrono::system_clock::time_point endTime = std::chrono::system_clock::now();

    std::cout << "当前总数为:" << globalCount << std::endl;
    std::cout << "消耗时间为：" << std::chrono::duration_cast<std::chrono::milliseconds> (endTime - startTime).count() <<"毫秒"<< std::endl;
    getchar();

    return 0;
}

3.2 使用互斥量保证线程互斥

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

long long globalCount = 0;
std::mutex globalMutex;

void ThreadFunction()
{
    std::lock_guard<std::mutex> lock(globalMutex);
    for (int i=0;i<100000;++i)
    {
        globalCount += 1;
    }
}

int main()
{
    std::vector<std::thread> threads;

    std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now();

    for (int i = 0; i < 10; ++i)
    {
        threads.push_back(std::thread(ThreadFunction));
    }

    for (int i=0;i<10;++i)
    {
        threads[i].join();
    }
    std::chrono::system_clock::time_point endTime = std::chrono::system_clock::now();

    std::cout << "当前总数为:" << globalCount << std::endl;
    std::cout << "消耗时间为：" << std::chrono::duration_cast<std::chrono::milliseconds> (endTime - startTime).count() <<"毫秒"<< std::endl;
    getchar();

    return 0;
}

3.3 使用原子量std::atomic保证数据互斥

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

std::atomic<long> globalCount = 0;

void ThreadFunction()
{
    for (int i=0;i<100000;++i)
    {
        globalCount += 1;
    }
}

int main()
{
    std::vector<std::thread> threads;

    std::chrono::system_clock::time_point startTime = std::chrono::system_clock::now();

    for (int i = 0; i < 10; ++i)
    {
        threads.push_back(std::thread(ThreadFunction));
    }

    for (int i=0;i<10;++i)
    {
        threads[i].join();
    }
    std::chrono::system_clock::time_point endTime = std::chrono::system_clock::now();

    std::cout << "当前总数为:" << globalCount << std::endl;
    std::cout << "消耗时间为：" << std::chrono::duration_cast<std::chrono::milliseconds> (endTime - startTime).count() <<"毫秒"<< std::endl;
    getchar();

    return 0;
}