C++武艺修炼--基于C++11利用原子变量实现多线程循环改写同一数据

该项目是基于C++11利用原子变量实现多线程循环改写同一数据。

假如魏蜀吴三国都想从某地（XX地区）“割韭菜”，但是这三国还不能在XX地区相遇，如果相遇了，可能会导致大打出手，伤了和气。那么只能安排魏蜀吴三国一天中的不同时间段过来XX地区割韭菜。曹操早上来，刘备中午来割，孙权下午来割，这样会顾及到每个收割者，也给了韭菜充分生长的时间，便于更好的被收割，直到把韭菜收割殆尽。岂不妙哉！！！
那么简单捋一下思路：

1. 那么用C++11去实现的话，把魏蜀吴分别用线程表示（AA,BB,CC）分别去执行自己的任务。
2. 魏蜀吴（AA,BB,CC）还需要达到相互制衡的关系，AA在收割的同时，BB,CC不能过去（不能执行），要不然AA可能会说“冒昧的家伙，你💩”。那么相互制衡，这里需要用到原子变量。
3. 最后就是魏蜀吴（AA,BB,CC）日复一日年复一年收割XX地区的韭菜（到这里，我有个朋友彻底破防了😭😭😭，对，是我的一个朋友，不是我😭😭😭）。这里需要用循环，以及判断等待上家是否收割完毕。

事先声明一下，该文章是比较水（虽然我写的，但是不妨碍我觉得是特别特别水）的原创，属于利用轮子实现功能的例子，这里也只是为后期的更新做铺垫，但是对于学习并发编程的小伙伴或许有着一点点意义即可。感谢Anthony Williams老师编著的《C++并发编程实战》（特别感谢吴天明老师的翻译），也特别感谢我的同事老毕给提的需求，感谢！！！

那么接下来准备实现。

先定义.h头文件：

#include <atomic>
#include <thread>
#include <assert.h>
#include <iostream>
#include <chrono>

class ThreadAtomic
{
public:
    ThreadAtomic();
    ~ThreadAtomic() = default;
public:
    void RunFun();
    void setStop(bool Stop);

    void threadWrite_AA();
    void threadWrite_BB();
    void threadWrite_CC();
private:
    std::atomic<bool> bo_AA, bo_BB, bo_CC;
    std::atomic<int> m_iData; //被收割的对象，每收割一次就累计加1（伤害值哦）
    bool m_Stop;
};

其次.cpp实现：

#include "ThreadAtomic.h"

ThreadAtomic::ThreadAtomic() :
    bo_AA(false),
    bo_BB(false),
    bo_CC(false),
    m_iData(0),
    m_Stop(false)
{
}

void ThreadAtomic::threadWrite_AA()
{
    while(m_Stop)
    {
        while(!bo_AA.load(std::memory_order_acquire))
        	std::this_thread::yield(); //让出处理器
        if(!bo_CC.load(std::memory_order_acquire) && !bo_BB.load(std::memory_order_acquire))
        {
            m_iData += 1;
            std::cout << "---------threadWrite_AA::::A----:::" << m_iData << std::endl;
            std::this_thread::sleep_for(std::chrono::seconds(1));
            bo_AA.store(false,std::memory_order_release);
            bo_BB.store(true,std::memory_order_release);
        }
    };
}

void ThreadAtomic::threadWrite_BB()
{
    while(m_Stop)
    {
        while(!bo_BB.load(std::memory_order_acquire))
        	std::this_thread::yield();
        if(!bo_CC.load(std::memory_order_acquire) && !bo_AA.load(std::memory_order_acquire))
        {
            m_iData += 1;
            std::cout << "---------threadWrite_BB::::B----:::" << m_iData << std::endl;
            std::this_thread::sleep_for(std::chrono::seconds(1));
            bo_BB.store(false,std::memory_order_release);
            bo_CC.store(true,std::memory_order_release);
        }
    };
}

void ThreadAtomic::threadWrite_CC()
{
    while(m_Stop)
    {
        while(!bo_CC.load(std::memory_order_acquire))
        	std::this_thread::yield();
        if(!bo_AA.load(std::memory_order_acquire) && !bo_BB.load(std::memory_order_acquire))
        {
            m_iData += 1;
            std::cout << "---------threadWrite_CC::::C----:::" << m_iData << std::endl;
            std::this_thread::sleep_for(std::chrono::seconds(1));
            bo_CC.store(false,std::memory_order_release);
            bo_AA.store(true,std::memory_order_release);
        }
    };
}

void ThreadAtomic::setStop(bool Stop)
{
    m_Stop = Stop;
}

void ThreadAtomic::RunFun()
{
    std::thread AA(&ThreadAtomic::threadWrite_AA, this);
    std::thread BB(&ThreadAtomic::threadWrite_BB, this);
    std::thread CC(&ThreadAtomic::threadWrite_CC, this);
    m_Stop = true;
    bo_AA.store(true,std::memory_order_release); //先定义AA，让AA先执行
    AA.join();
    BB.join();
    CC.join();
}

最后就是调用时刻啦：

int main(int argc, char *argv[])
{
    ThreadAtomic* threadAt = new ThreadAtomic();
    threadAt->RunFun(); //调用
    return 0
}

最后看一下打印输出：

那么功能完成啦，拿拿拿–拿–捏。如果有觉得不理解的地方，可以查阅相关资料。有喜欢的，非要关注我的也不是不可以🫢🫢🫢，那俺大不了就和你说声谢谢。完事的可以陆陆续续撤啦！

---

那么又是俺的不正经时刻啦！

写于2015年上大一的时候吧，想想都多少年啦。最近主要有看到很多大学生毕业，整个就业市场又特别不好，很多人都没有信心，特别迷茫。就想着把这个分享一下子吧，献给最美丽的你们（所有正值青春年华的你们）。

青春

青春是一支孤独的笔
写下的浪漫诗意都是你
\n

青春是一把普通的尺
度量的数都是有误差的值
\n

青春是一块精美的橡皮
擦去的叫刻意 擦不去的是痕迹
\n

青春是一首自作的诗
写出的只是表面的字
没写出的只有自己知
\n

又有人说
青春是一幅模糊的画
看得清的是风景
看不见的叫年华

好啦，祝福上学的你学业顺利，祝福找工作的你顺利找到好工作，祝福工作了的你每天开心，每天笑哈哈，牛马也得做个通透乐呵的牛马，是吧。