C++11 语言特性和标准库 并发

#include <algorithm>
#include <vector>
#include <iostream>
#include <string>
#include <memory>
#include <thread>
#include <chrono>
#include <functional>


using namespace std;


/*
    1、语法说明
    2、使用说明
    3、使用场景
*/


#define PRINT(s) std::cout << s << std::endl;
#define LOG(s) std::cout << #s << ":" << s << std::endl;
#define TLOG(t,s) std::cout << t << ":" << s << std::endl;




class OneClass
{
public:
    std::string str_;
    OneClass(const char* str) :str_(str) {    }


    void operator()() {
        LOG(str_);
    }
};


void OneFunc(std::string str)
{
    TLOG("OneFunc", str);
    if (this_thread::get_id() == thread::id()) {
        PRINT("get_id() == id()");
    }
}


void FuncNativeHandle(int seconds1)
{
    this_thread::sleep_for(chrono::seconds(seconds1));
    PRINT("FuncNativeHandle Finish");
}


void FuncYield(std::string str)
{
    TLOG("FuncYield begin", str);
    //1. 让渡,降低自己的优先级,让别的线程有机会调用,也就是建议CPU分配资源给其他线程。
    //2. 注意在多线程个数超出cpu核心的个数有效.
    //3. 通常情况下用在监听事件里，比如判断某些消息没传来，不着急循环调用，先调用yield()能让当前线程让渡CPU资源,比sleep更能提高性能.
    int count = 0;
    for (int i = 0; i < 10000; ++i) {
        count += (i % 5);
        this_thread::yield();
    }
    TLOG("FuncYield end", str);
}


void FuncNoYield(std::string str)
{
    TLOG("FuncNoYield begin", str);
    int count = 0;
    for (int i = 0; i < 10000; ++i) {
        count += (i % 5);
    }
    TLOG("FuncNoYield end", str);
}


void CreateJoinableThreads()
{
    PRINT("================= CreateJoinableThreads ==============");
    // 创建thread; 需绑定函数或函数对象
    // 绑定重载了operator()的类
    thread t1(OneClass("vic.MINg"));
    t1.join();


    // 绑定函数
    thread t2(OneFunc, "vic.MINg");
    t2.join();


    // 绑定lambda表达式,如果线程是detach线程
    // 传给lambda表达式的外部变量生命周期要是堆内存变量.
    thread t3([](const char* str) {
        TLOG("Lambda", str);
    }, "vic.MINg");
    t3.join();


    // 绑定 std::function
    thread t4(bind(OneFunc, "vic.MINg"));
    t4.join();


    thread t5; // 未启动线程,无用,C++11没有提供后续的启动线程方法.
    LOG(t5.joinable());


    thread t6(OneFunc, "Join");
    TLOG("t6 join() before", t6.joinable());


    t6.join(); // 调用join()之后也是不可joinable();
    TLOG("t6 join() after", t6.joinable());


    thread t7(OneFunc, "Detach");
    t7.detach(); // 调用了detach之后是不可joinable的.
    TLOG("t7 detach(): ", t6.joinable());
}


void ThreadOtherFunc()
{
    PRINT("================= ThreadOtherFunc ==============");
    // 获取最佳的并行线程个数, 即CPU核心个数.
    auto number = thread::hardware_concurrency();
    LOG(number);


    // 获取线程ID的散列码
    hash<thread::id> hasher;
    auto _id = hasher(this_thread::get_id());
    TLOG("Thread hash ID(size_t)", _id);


    // sleep_util, 参数是time_point, 直到某个时刻.
    //   当前时间往后推2秒
    auto begin = chrono::steady_clock::now();
    auto tti = time(NULL);
    tm tm1;
#ifdef _WIN32
    localtime_s(&tm1, &tti);
#else
    tm1 = *localtime(&tti);
#endif


    tm1.tm_sec += 2;
    auto tti2 = mktime(&tm1);
    auto ti = chrono::system_clock::from_time_t(tti2); // 换算需要耗费时间
    this_thread::sleep_until(ti);
    auto offset = chrono::steady_clock::now() - begin;
    auto millseconds1 = chrono::duration_cast<chrono::milliseconds>(offset);
    TLOG("sleep_until millseconds", millseconds1.count());


    // 获取底层实现的本地线程句柄，比如Windows VS2017的返回 HANDLE,gcc返回的是pthread句柄.
    thread t1(FuncNativeHandle, 5);
    auto handle = t1.native_handle();
    TLOG("handle", handle);
    t1.join();
}


void ThreadYield()
{
    PRINT("================= ThreadYield ==============");
    std::vector<thread*> args;
    for (int i = 0; i < 10; ++i) {
        thread* t1 = NULL;
        if (i % 5)
            t1 = new thread(FuncNoYield, "ThreadYield" + to_string((long long)i));
        else
            t1 = new thread(FuncYield, "ThreadYield" + to_string((long long)i));


        args.push_back(t1);
    }


    for (int i = 0; i < args.size(); ++i)
        (*args[i]).join();
}


void CreateDetachThreads()
{
    PRINT("================= CreateDetachThreads ==============");
    thread t1([]() {
        std::this_thread::sleep_for(std::chrono::seconds(2));
        PRINT("Detach Thread");
    });
    t1.detach();
}


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


int main(int argc, char const *argv[])
{
    std::cout << "---------- 1、语法说明 ---------------" << std::endl;
    // C++11 的 thread 线程类如果要激活使用必须在创建时传入线程处理函数或函数对象，无参的默认构造函数目前没有什么用, 目前 thread 类并没有 operator() 的重载支持后续添加处理函数。
    // 注意, thread类禁用了复制构造函数。


    std::cout << "---------- 2、使用说明 ---------------" << std::endl;
    // 1、 线程是程序执行/计算的表示。在 C++11 中，就像在许多现代计算中一样，一个线程可以（通常也确实）与其他线程共享一个地址空间。
    //          在这一点上，它与进程不同，后者通常不直接与其他进程共享数据。
    //          在过去，C++ 已经为各种硬件和操作系统提供了大量的线程实现，现在的新特性是标准库线程库。


    // 2、C++ 的委员会 POSIX 代表强烈反对任何形式的“线程取消”，原因是大多数的 C++ 的资源模型依赖于析构函数。对于每个系统和每个可能的应用程序，都没有完美的解决方案。


    // 3、C++11的线程和大多数的平台的 C/C++ 实现是一样的，有两种类别的线程, joinable 和 detach 线程，即可加入等待的线程，可分离的线程；
    //         可 joinable 的线程当调用线程的方法 join(), 可在主线程里等待工作线程结束再执行下一条语句；
    //         可分离的线程调用 detach() 方法，之后即便 thread 实例对象销毁，线程处理函数一样继续执行（底层线程执行内核句柄并没销毁）。


    // 4、线程的基本问题是数据竞争；也就是说，在一个地址空间中运行的两个线程可以以导致未定义结果的方式独立地访问一个对象。
    //         如果一个(或两个)写对象，而另一个(或两个)读对象，他们有一个“竞赛”谁先完成它的操作。
    //         结果不仅没有定义; 它们通常是完全不可预测的。因此，C++11 为程序员提供了一些规则 / 保证来避免数据竞争：
    //         -- C++ 标准库函数不能直接或间接地访问当前线程以外的线程可以访问的对象，除非这些对象是通过函数的参数直接或间接地访问的，包括 this;
    //         -- C++ 标准库函数不能直接或间接地修改当前线程以外的线程可以访问的对象，除非这些对象是通过函数的非常量参数直接或间接地访问的，包括this。
    //         -- 当同时修改同一序列中的不同元素时，需要使用 C++ 标准库实现来避免数据竞争。
    //         -- 除非另有说明，否则多线程并发访问流对象、流缓冲区对象或 C库流可能导致数据竞争。所以不要在两个线程之间共享输出流，除非您能够控制对它的访问。


    std::cout << "---------- 3、使用场景 ---------------" << std::endl;


    CreateJoinableThreads();
    ThreadOtherFunc();
    ThreadYield();
    CreateDetachThreads();


    system("pause");


    return 0;
}

#include <algorithm>
#include <vector>
#include <iostream>
#include <random>
#include <string>
#include <assert.h>
#include <memory>
#include <thread>
#include <chrono>
#include <functional>
#include <mutex>
using namespace std;


/*
    1、语法说明
    2、使用说明
    3、使用场景
*/


#define PRINT(s) std::cout << s << std::endl;
#define LOG(s) std::cout << #s << ":" << s << std::endl;
#define TLOG(t,s) std::cout << t << ":" << s << std::endl;


static mutex m;
void MutexLock(int count, int loopTimes)
{
    PRINT("================= MutexLock ==============");
    auto args = new std::vector<int>();
    shared_ptr<std::vector<int>> sp_args(args);
    auto threads = new std::vector<thread*>();
    shared_ptr<std::vector<thread*>> sp_threads(threads);


    for (int i = 0; i < count; ++i) {
        auto t1 = new thread([&args](mutex *m, int loopTimes) {


            for (int j = 0; j < loopTimes; ++j) {
                m->lock();
                args->push_back(j);
                m->unlock();
            }
            hash<thread::id> hasher;
            auto _id = hasher(this_thread::get_id());
            TLOG("thread finish hash id: ", _id);
        }, &m, loopTimes);
        threads->push_back(t1);
    }


    for (auto one : *threads) {
        one->join();
        delete one;
    }


    auto size = args->size();
    LOG(size);
    LOG(count*loopTimes);
    LOG((count* loopTimes == size));
}




void MutexTryLock(int count, int loopTimes)
{
    PRINT("================= MutexTryLock ==============");
    auto args = new std::vector<int>();
    shared_ptr<std::vector<int>> sp_args(args);
    auto threads = new std::vector<thread*>();
    shared_ptr<std::vector<thread*>> sp_threads(threads);


    for (int i = 0; i < count; ++i) {
        auto t1 = new thread([&args](mutex *m, int loopTimes) {
            hash<thread::id> hasher;
            auto _id = hasher(this_thread::get_id());
            for (int j = 0; j < loopTimes; ++j) {
                // 不一定能获取锁,不会等待其他线程解锁，获取不到直接解锁.
                if (m->try_lock()) {
                    args->push_back(j);
                    this_thread::sleep_for(chrono::milliseconds(10));
                    m->unlock();
                }
            }


            TLOG("thread finish hash id: ", _id);
        }, &m, loopTimes);
        threads->push_back(t1);
    }


    for (auto one : *threads) {
        one->join();
        delete one;
    }


    auto size = args->size();
    LOG(size);
    LOG(count*loopTimes);
    LOG((count* loopTimes >= size));
}


int rand_int(int low, int max)
{
    static default_random_engine re;
    using Dist = uniform_int_distribution<int>;
    static Dist dt;
    return dt(re, Dist::param_type(low, max));
}


void Func(std::vector<int>* args, std::recursive_mutex* m)
{
    m->lock();
    args->push_back(rand_int(100, 10000));
    m->unlock();
}


void ThreadFunc(std::vector<int>* args, std::recursive_mutex* m)
{
    hash<thread::id> hasher;
    auto _id = hasher(this_thread::get_id());


    m->lock(); // lock和unlock要匹配,不然不会释放锁.
    TLOG("BEGIN: ThreadFunc hash id: ", _id);
    for (int i = 0; i < 100; ++i) {
        args->push_back(i);
        Func(args, m);
    }
    TLOG("END: ThreadFunc hash id: ", _id);
    m->unlock();
}




void RecursiveMutex(int count)
{
    PRINT("================ RecursiveMutex =================");
    // 避免这种递归锁的设计.
    recursive_mutex rm;
    auto args = new std::vector<int>();
    shared_ptr<std::vector<int>> sp_args(args);


    auto threads = new std::vector<thread*>();
    shared_ptr<std::vector<thread*>> sp_threads(threads);


    for (int i = 0; i < count; ++i) {
        auto t1 = new thread(ThreadFunc, args, &rm);
        threads->push_back(t1);
    }


    for (auto one : *threads) {
        one->join();
        delete one;
    }


    LOG(args->size());
}




void TimeMutex()
{
    PRINT("================ TimeMutex =================");
    std::timed_mutex m2;
    // 最长时间尝试5秒获取锁，超过时间未获取锁就放弃.
    if (m2.try_lock_for(chrono::seconds(5))) {
        PRINT("try_lock_for");
        m2.unlock();
    }




    // try_lock_util,最长时间到指定time_point时刻如果未获取锁就放弃
    auto begin = chrono::steady_clock::now();
    auto tti = time(NULL);
    tm tm1;
#ifdef _WIN32
    localtime_s(&tm1, &tti);
#else
    tm1 = *localtime(&tti);
#endif


    tm1.tm_sec += 5;
    auto tti2 = mktime(&tm1);
    auto ti = chrono::system_clock::from_time_t(tti2); // 换算需要耗费时间
    if (m2.try_lock_until(ti)) {
        auto offset = chrono::steady_clock::now() - begin;
        auto millseconds1 = chrono::duration_cast<chrono::milliseconds>(offset);
        TLOG("try_lock_util millseconds", millseconds1.count());
        m2.unlock();


    }




}


/////////////////////////////////////////////////////////////////////////////////////////////////
int main(int argc, char const *argv[])
{
    std::cout << "---------- 1、语法说明 ---------------" << std::endl;
    // C++11 的 mutex 类别有 std::mutex（普通互斥量），std::timed_mutex（带超时的互斥量）, std::recursive_mutex（重入互斥量）, recursive_timed_mutex（重入时间互斥量）。
    // mutex 只有默认构造函数，不支持复制构造函数。
    std::cout << "---------- 2、使用说明 ---------------" << std::endl;
    // 1、mutex 使用方法 lock() 和 unlock() 必须成对出现，不然会出现锁不释放造成线程挂起，或者 unlock 多调用导致共享变量提前解锁崩溃的情况。


    // 2、对于可重入 recursive_mutex，在一个线程获取锁后，在调用 unlock() 之前会一直持有锁，这个线程会一直保留锁，
    //         如果这个线程调用其他函数也尝试同一个 recursive_mutex，那么也会成功，即同一个线程可同时获取多次同一个可重入锁。
    //         recursive_mutex会计数获取锁的次数，lock() + 1，unlock() - 1. 必须成对出现，不然会出现第一种情况。


    // 3、对于超时 timed_mutex 的 try_lock_xx, 就是在指定秒数或时刻这段时间或尝试获取锁，如果超过这个时间就会放弃获取锁，执行后边的代码。


    std::cout << "---------- 3、使用场景 ---------------" << std::endl;
    MutexLock(10, 100);
    MutexTryLock(10, 100);
    RecursiveMutex(10);
    TimeMutex();


    system("pause");


    return 0;
}

#include <algorithm>
#include <vector>
#include <iostream>
#include <string>
#include <memory>
#include <thread>
#include <chrono>
#include <mutex>
#include <functional>


using namespace std;


/*
    1、语法说明
    2、使用说明
    3、使用场景
*/


#define PRINT(s) std::cout << s << std::endl;
#define LOG(s) std::cout << #s << ":" << s << std::endl;
#define TLOG(t,s) std::cout << t << ":" << s << std::endl;


static std::mutex m;
static std::mutex m1;
void Lock(int count, int loopTimes)
{
    auto args = new std::vector<int>();
    shared_ptr<std::vector<int>> sp_args(args);
    auto threads = new std::vector<thread*>();
    shared_ptr<std::vector<thread*>> sp_threads(threads);


    for (int i = 0; i < count; ++i) {
        auto t1 = new thread([&args](mutex *m, mutex *m1, int loopTimes) {


            for (int j = 0; j < loopTimes; ++j) {
                // 默认获取锁
                std::unique_lock<std::mutex> lk(*m);
                args->push_back(j);


                // 支持move操作
                std::unique_lock<std::mutex> lk2(std::move(lk));
                args->push_back(j);
            }


            for (int j = 0; j < loopTimes; ++j) {
                // 先绑定，先不获取锁
                std::unique_lock<std::mutex> lk(*m, std::defer_lock);
                // 不需要匹配unlock(),因为lk在析构时会释放锁.
                if (lk.try_lock()) {
                    args->push_back(j);
                }
            }


            for (int j = 0; j < loopTimes; ++j) {
                // 同步多个锁，这样避免在释放时没有匹配所有unlock.
                std::unique_lock<std::mutex> lk(*m, std::defer_lock);
                std::unique_lock<std::mutex> lk2(*m1, std::defer_lock);
                // 不需要匹配unlock(),因为lk在析构时会释放锁.
                if (std::try_lock(lk, lk2)) {
                    args->push_back(j);
                }
            }


            for (int j = 0; j < loopTimes; ++j) {
                // 同步多个锁，这样避免在释放时没有匹配所有unlock.
                std::unique_lock<std::mutex> lk(*m, std::defer_lock);
                std::unique_lock<std::mutex> lk2(*m1, std::defer_lock);
                // 不需要匹配unlock(),因为lk在析构时会释放锁.
                std::lock(lk, lk2);
                args->push_back(j);
            }


            hash<thread::id> hasher;
            auto _id = hasher(this_thread::get_id());
            TLOG("thread finish hash id: ", _id);
        }, &m, &m1, loopTimes);
        threads->push_back(t1);
    }


    for (auto one : *threads) {
        one->join();
        delete one;
    }


    auto size = args->size();
    LOG(size);
    LOG(count*loopTimes);
    LOG((count* loopTimes == size));
}




/////////////////////////////////////////////////////////////////////////////////////////////////
int main(int argc, char const *argv[])
{
    std::cout << "---------- 1、语法说明 ---------------" << std::endl;
    // C++11的<mutex>里增加了一个unique_lock类，用来管理一个或多个互斥量。
    // 它不需要匹配调用 lock() 和 unlock()，因为它的实例的析构会释放锁，支持合并多个锁和移动锁对象；但是不支持可重入锁。
    std::cout << "---------- 2、使用说明 ---------------" << std::endl;
    // 当有两个共享变量需要不同的 mutex 加锁时？我们使用 lock()，unlock() 如果不匹配的话很容易造成死锁。
    // unique_lock 提供合并锁：同时需要锁定多个 mutex 才会执行下一步，unique_lock 析构时也会同时释放。
    std::cout << "---------- 3、使用场景 ---------------" << std::endl;


    Lock(10, 100);
    system("pause");


    return 0;
}

#include <algorithm>
#include <queue>
#include <iostream>
#include <string>
#include <memory>
#include <thread>
#include <random>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <functional>


using namespace std;


/*
    1、语法说明
    2、使用说明
    3、使用场景
*/


#define PRINT(s) std::cout << s << std::endl;
#define LOG(s) std::cout << #s << ":" << s << std::endl;
#define TLOG(t,s) std::cout << t << ":" << s << std::endl;


static mutex m;
static condition_variable cv;
bool ready = true;




int rand_int(int low, int max)
{
    static default_random_engine re;
    using Dist = uniform_int_distribution<int>;
    static Dist dt;
    return dt(re, Dist::param_type(low, max));
}


void FuncFirst(std::queue<int>* args, mutex* m, condition_variable* cv)
{
    PRINT("FuncFirst BEGIN");
    int count = 0;
    do {
        std::unique_lock<std::mutex> lk(*m);
        // 接收到通知，但是还是要判断是否Second是否准备好接收数据
        cv->wait(lk, []() {return ready; });
        auto value = rand_int(100, 10000);
        args->push(value);
        TLOG("push", value);
        ready = false;
        lk.unlock();
        cv->notify_all();
        if (++count == 10)
            break;
    } while (true);
    PRINT("FuncFirst END");
}


void FuncSecond(std::queue<int>* args, mutex* m, condition_variable* cv)
{
    PRINT("FuncSecond BEGIN");
    int count = 0;
    do {
        std::unique_lock<std::mutex> lk(*m);
        cv->wait(lk, []() {return !ready; });
        while (!args->empty()) {
            TLOG("pop", args->front());
            args->pop();
        }


        ready = true;
        lk.unlock();
        cv->notify_all();
        if (++count == 10)
            break;


    } while (true);
    PRINT("FuncSecond END");
}


void ConditionVariable()
{
    std::queue<int> args;
    thread t1(FuncFirst, &args, &m, &cv);
    thread t2(FuncSecond, &args, &m, &cv);
    t1.join();
    t2.join();


}


/////////////////////////////////////////////////////////////////////////////////////////////////
int main(int argc, char const *argv[])
{
    std::cout << "---------- 1、语法说明 ---------------" << std::endl;
    // 类 condition_variable 创建时使用默认构造函数，不允许使用复制构造函数。
    std::cout << "---------- 2、使用说明 ---------------" << std::endl;
    // 1、condition_variable（条件变量）一般用在控制多线程的顺序上，某个线程没任务时需要等待条件变量通知才能继续执行；
    //         比如线程A需要等待线程B通知某个条件满足了，之后A收到通知后，执行逻辑。
    //         而B线程可以等待或不等待A执行结束，B可以继续执行自己的逻辑。


    // 2、条件变量需要满足条件下才会执行逻辑，而锁是只要得到锁即可继续执行，而没满足条件时进入等待，比单纯加锁 CPU 利用率高。


    // 3、条件变量 wait 结束后，也是会重新获取锁；继续执行的语句也是在获取锁的情况下执行；也就是说条件变量和 mutex 是搭配使用的。
    std::cout << "---------- 3、使用场景 ---------------" << std::endl;
    // 条件变量，最常用的就是用 wait() 和 notify_xx() 方法，一个是等待通知，一个通知等待可以继续执行。
    // 如果有多个等待，那么锁的获取即使竞赛获取的，哪个线程先获取不确定。以下实现简单生产消费者模式的两个线程。


    ConditionVariable();
    system("pause");


    return 0;
}

#include <algorithm>
#include <vector>
#include <iostream>
#include <string>
#include <string.h>
#include <memory>
#include <thread>
#include <mutex>
#include <chrono>
#include <functional>
#include <atomic>


using namespace std;


/*
    1、语法说明
    2、使用说明
    3、使用场景
*/


#define PRINT(s) std::cout << s << std::endl;
#define LOG(s) std::cout << #s << "->" << s << std::endl;
#define TLOG(t,s) std::cout << t << "->" << s << std::endl;


static mutex m;


void Atomic(int count)
{
    PRINT("============ Atomic ==========");
    // typedef atomic<int>            atomic_int;
    // 创建并初始化值
    atomic_int at(0);
    // +=operator 相当于 at.fetch_add(arg), 原子操作.
    at += 5;
    TLOG("+=", at);


    // 原子加法
    at.fetch_add(5);
    TLOG("fetch_add", at);


    // 比较原值是否是期望的值，如果是，那么修改原值
    // atomic_compare_exchange_strong: 强类型不需要while循环比较,没有虚假地址失败.
    // 大多数情况下用强类型比较即可.
    int at1 = 10;
    if (std::atomic_compare_exchange_strong(&at, &at1, 90))
        TLOG("atomic_compare_exchange_strong", at);


    // atomic_compare_exchange_weak
    // 函数的弱形式（ (1) 与 (3) ）允许虚假地失败，即表现为如同 *obj != *expected ，即使它们相等。
    // 当比较并交换在循环中时，弱版本在某些平台上会生成更好的性能。
    at1 = at;
    while (!atomic_compare_exchange_weak(&at, &at1, 100));
    TLOG("atomic_compare_exchange_strong", at);




    //  使用内存顺序,读取写入指定内存顺序，一般用在内存块比较多的情况下进行优化。数值整型性能影响不大.
    int i2 = 100;
    // memory_order_relaxed    宽松操作：没有同步或顺序制约，仅对此操作要求原子性
    // memory_order_release    有此内存顺序的存储操作进行释放操作：当前线程中的读或写不能被重排到此存储后。
    //   当前线程的所有写入，可见于获得该同一原子变量的其他线程释放获得顺序），
    //                       并且对该原子变量的带依赖写入变得对于其他消费同一原子对象的线程可见
    if (std::atomic_compare_exchange_strong_explicit(&at, &i2, -90,
        std::memory_order_release, std::memory_order_relaxed)) {
        TLOG("atomic_compare_exchange_strong_explicit", at);
    }


    // 多线程+,无锁,效率比 mutex.lock() 高很多.
    //  值没有因多线程出现互相覆盖的情况.
    atomic_int at2(0);
    std::vector<thread> args;
    for (int i = 0; i < count; ++i) {
        args.emplace_back([](atomic_int* a) {
            for (int j = 0; j < 100; ++j) {
                //    a->fetch_add(1);
                (*a) += 1;
            }
        }, &at2);
    }


    for (auto &one : args) {
        one.join();
    }


    LOG(at2);
    LOG(count * 100);
    LOG((at2 == count * 100));
}




void AtomicClass(int count)
{
    PRINT("============ AtomicClass ==========");
    // 原子操作字符串指针,一般用在显示进度文字。
    atomic<char*> a(nullptr);
    std::vector<thread> args;
    for (int i = 0; i < count; ++i) {
        args.emplace_back([](atomic<char*>* a, int index) {
            auto str = "hello:" + std::to_string((long long)index);
            auto size = str.size();
            auto buf = (char*)malloc(size + 1);
#ifdef  _WIN32
            strncpy_s(buf, size + 1, str.c_str(), size);
#else
            strncpy(buf, str.c_str(), size);
#endif //  _WIN32




            buf[size] = 0;
            char*atomicBuf = NULL;
            m.lock();
            TLOG("buf: ", buf);
            m.unlock();
            if ((atomicBuf = atomic_exchange(a, buf))) {
                m.lock();
                TLOG("atomicBuf: ", atomicBuf);
                m.unlock();
                free(atomicBuf);
            }


        }, &a, i);
    }


    for (auto &one : args) {
        one.join();
    }


    char* atomicBuf = NULL;
    if ((atomicBuf = atomic_exchange(&a, (char*)NULL))) {
        TLOG("Last atomicBuf: ", atomicBuf);
        free(atomicBuf);
    }


    // 不允许使用string作为特化类型，因为string不是 trivially copyable(扁平可复制的) 类型。
    // 多线程情况下, 行为是未定义的。可以是C结构体或者我们之前讲的章节"Generalized PODs,广义的扁平简单数据类型)。
    // 编译失败
    // error: static assertion failed: std::atomic requires a trivially copyable type
    // atomic<string> at("");
    // atomic_exchange(&at,std::string("vic.MINg"));


    // https://zh.cppreference.com/w/cpp/atomic/memory_order




}


/////////////////////////////////////////////////////////////////////////////////////////////////
int main(int argc, char const *argv[])
{
    std::cout << "---------- 1、语法说明 ---------------" << std::endl;
    // 类std::atomic创建时可以使用默认构造函数，也有带特化类型的初始化参数， 不支持复制构造函数。
    std::cout << "---------- 2、使用说明 ---------------" << std::endl;
    // 1、atomic<T>原子类只支持扁平的数据结构类型，扁平数据结构即可以通过memcpy进行位复制的类型，而不影响该类的使用。
    //         比如C类型 struct, 原始数值类型，union类型，PODs类型等。


    // 2、原子类型操作通过原子对象的方法进行数值运算。
    //         或者通过全局函数 std::atomic_exchange 等进行数值运算, 可对应上 Windows 的 Win32函数 InterlockedExchange 等。


    // 3、在多线程场景下，能用原子操作的就不要使用 <mutex> 互斥量，因为原子操作性能高很多倍。
    //         原子函数或对象的操作是保证修改或读取的对象不会因为多核情况下并发修改导致错误的值得情况。
    //         但是一些复合类型，比如 std::vector 并不是 PODs 对象，是用不了原子操作的。
    std::cout << "---------- 3、使用场景 ---------------" << std::endl;
    Atomic(10);
    AtomicClass(10);


    system("pause");
    return 0;
}