线程中future/atomic/async及nlohmann json的学习

1)std::future的其他成员函数

wait_for()成员函数，wait_for返回的是一个std::future_status枚举类型,根据返回值做相应处理
std::future_status state = result.wait_for(std::chrono::seconds(1));
if(state == std::future_status::ready)
{
cout< cout<<“ready”< }

2)std::future的类模板中的get()方法，采用的是移动语义，所有不能多次get();

  shared_future也是一个类模板，get()成员函数是复制操作，所以可以多次get()；
#include 
#include
#include
#include
#include

using namespace std;

int func(void)
{
        cout<<"start----- thread_id is : "<<std::this_thread::get_id()<<endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(2000));
        cout<<"end-------- thread_id is : "<<std::this_thread::get_id()<<endl;
        return 5;
}

int main()
{
        cout<<"main thread start----- thread_id is : "<<std::this_thread::get_id()<<endl;
        std::future<int> result = std::async(func); 
        std::shared_future<int> sharedRes = result.share(); //用future的shared成员函数返回值，生成一个shared_future对象
        cout<<sharedRes.get()<<endl;  //shared_future可以多次get
        cout<<sharedRes.get()<<endl;  
        cout<<"********main run*********"<<endl;   
        return 0;
}

3)原子操作:std::atomic的使用，atomic是一个类模板

//可以用互斥锁进行共享数据访问，但用原子操作的话，用的时间比互斥锁使用的时间短；
//原子操作主要操作的是一个变量,一般用于计数或者统计！
#include 
#include
#include

using namespace std;

std::atomic<long> gCount; //封装成一个原子类对象；定义成一个原子的全局量;
void func(void)
{
        for(long int i = 0; i<10000000; i++)
        {
                gCount++;　//gCount = gCount + 1;这样写，数据就不对了,原子操作不是所有的操作符都成立！！！
		//当拿不准的时候，就得需要测试一下；
        }
}

int main()
{
        gCount = 0;
        thread t1(func);
        thread t2(func);
        t1.join();
        t2.join();
        cout<<gCount<<endl;
        return 0;
}

4)std::async深入学习

async()，我们不叫他创建一个线程(虽然有时候可以创建一个线程)，我们称创建一个异步任务！
async和thread最大的区别就是，async有时候不会创建线程。
std::future::deferred和std::launch::async是绑定在一起的，叫延迟调用！
用std::future_status就可以判断是延迟调用还是创建异步任务(创建新线程)；
#include 
#include
#include

using namespace std;

int func(void)
{
        cout<<"start----- thread_id is : "<<std::this_thread::get_id()<<endl;
        std::this_thread::sleep_for(std::chrono::seconds(2));
        return 1;
}

int main()
{
        cout<<"main----- thread_id is : "<<std::this_thread::get_id()<<endl;
        // 如果使用了std::launch::deferred这个枚举量，则func会延迟到future里面的get()或者wait()才会执行！！！
        // 如果一直没有遇到future的get或者wait函数，则func根本不会执行；
        // std::launch::async，强制这个异步任务在新线程执行；
        std::future<int> result = std::async(std::launch::deferred|std::launch::async,func); //缺省值为: std::launch::async|std::launch::deferred，由系统自行决定!
        // auto num = result.get(); //如果屏蔽到此条语句，func()函数根本不会执行！
        // cout<
        result.wait();
        return 0;
}


//自动析构技术lock_guard lock(mtx);
class A{ };

// 仿写lock_guard功能
class LockGuard
{
public:
        LockGuard(A* ptr) //进入构造函数加锁
        {
                a_ = ptr;
                mtx.lock();
        }
        ~LockGuard() //析构函数执行解锁
        {
                mtx.unlock();
        }
private:
        A* a_;        
        std::mutex mtx;
};

两个中文名：
//std::mutex　独占互斥量
//std::recursive_mutex 递归独占互斥量

５)nlohmann::json的学习
使用方法：
5.1)直接包含“single_include/nlohmann/json.hpp”头文件，这个头文件从网上一找一大片，很容易,包含完就可以用了。
5.2)理解并掌握一些成员函数，依然从网上找，so easy!!!

#include 
#include
#include "single_include/nlohmann/json.hpp"

using json = nlohmann::json;
using namespace std;

void writeFile(json& obj)
{
        obj.push_back({"1","jianghuaiwei"});
        obj.push_back({"2","suhui"});        
        std::ofstream("/home/jiang/11.txt") <<obj; //写文件
}

void readFile(json& obj)
{
        for(auto &e : obj.items())
        {
                cout<<e.key()<<" "<<e.value()<<endl;
        }
}

int main()
{
        json jj;
        // writeFile(jj); //写文件
        std::ifstream("/home/jiang/11.txt") >> jj; //读文件
        readFile(jj);
        return 0;
}