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<<result.get()<<endl;
cout<<“ready”<<endl;
}
2)std::future的类模板中的get()方法，采用的是移动语义，所有不能多次get();
shared_future也是一个类模板，get()成员函数是复制操作，所以可以多次get()；
#include <iostream>
#include<thread>
#include<mutex>
#include<list>
#include<future>
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 <iostream>
#include<thread>
#include<atomic>
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 <iostream>
#include<thread>
#include<future>
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<<num<<endl;
result.wait();
return 0;
}
//自动析构技术lock_guard<std::mutex> 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 <iostream>
#include<fstream>
#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;
}