1)promise(保证)和future的联合使用，实现两个线程的数据传递
#include <iostream>
#include<thread>
#include<future>
using namespace std;
//promise用法：可以给线程一个值，而从另一个线程读出该值
// 实现了两个线程的数据传递！
void myPromise(std::promise<int>& tmp,int num)//promise线程
{
//在这里假使处理复杂的计算，最后得出一个值，并返回
num = num + 20;
tmp.set_value(num);
}
//另一个线程可以得到promise计算后得到的值
void myFuture(std::future<int>& tmp)
{
cout<<"myFuture thread receive value is : "<< tmp.get()<<endl;
}
int main()
{
std::promise<int> pro;
std::thread th1(myPromise,std::ref(pro),10); //创建promise线程时，第二个参数一定要用引用
th1.join();
std::future<int> result = pro.get_future();
std::thread th2(myFuture,std::ref(result)); //std::ref( pro.get_future())用临时对象不可以；
th2.join();
return 0;
}
//输出结果：myFuture thread receive value is : 30
2) package_task的使用，把任务从新包装起来，案例代码如下：
#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::milliseconds(2000));
cout<<"end-------- thread_id is : "<<std::this_thread::get_id()<<endl;
return 5;
}
//package_task类模板,可以包装任何可调用对象
int main()
{
std::packaged_task<int()> task(func);
std::thread th(std::ref(task)); //package_task里面有一个成员函数get_future(),可以返回一个future对象；
th.join();
std::future<int> result = task.get_future();
cout<<result.get()<<endl;
return 0;
}
３）//std::async和std::future一起配合使用
#include <iostream>
#include<thread>
#include<mutex>
#include<list>
#include<future>
// std::async和std::future的用法：
// async是一个函数模板，启动一个线程;std::future是类模板，当async启动任务后，会返回std::future对象；
// std::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;
}
//std::launch::deferred参数时，等待wait或者get返回,如果没有这两个函数，直接运行接下来代码
//std::launch::deferred参数不会创建新线程！！！
//std::future两个成员函数，get是等待线程处理完返回结果；wait是等待线程处理完，不返回结果
int main()
{
cout<<"main thread start----- thread_id is : "<<std::this_thread::get_id()<<endl;
std::future<int> result = std::async(func); //程序不会卡到这里！！！这里存在一个绑定关系
cout<<"********main run*********"<<endl;
cout<<result.get()<<endl; //程序会卡到这里，等待线程返回结果（利用的是std::future的成员函数get）
return 0;
}
４）//条件变量与互斥量的配合使用方法：
#include <iostream>
#include<thread>
#include<mutex>
#include<list>
#include<condition_variable>
//条件变量是和互斥量配合使用！
using namespace std;
class A
{
public:
void inQueue(void)
{
for(int i = 0; i<10000;i++)
{
cout<<"insert message : "<<i<<endl;
{
std::unique_lock<std::mutex> uniqueLock(mtx);
message.push_back(i);
cond.notify_one();
}
}
}
void outQueue(void)
{
for(int i = 0 ; i<10000; i++)
{
std::unique_lock<std::mutex> uniqueLock(mtx); //自动加锁
//wait跟互斥量的关系：wait阻塞解锁，wait唤醒加锁！！！
cond.wait(uniqueLock,[this](){
//如果参数2是false,解锁等待;如果是true,加锁完成后，继续执行下面代码
if(!message.empty())
return true;
else
return false; //可以处理虚假唤醒,就是说容器没有数据，但被唤醒了，执行解锁等待。
});
int cmd = message.front();
message.pop_front();
cout<<"out cmd---------- is :"<<cmd<<endl;
}//出作用域，uniqueLock锁释放;
}
private:
std::list<int> message;
std::condition_variable cond;
std::mutex mtx;
};
int main()
{
A a;
std::thread th1(&A::inQueue,&a);
std::thread th2(&A::outQueue,&a);
th1.join();
th2.join();
return 0;
}
5)互斥量的使用方法：
#include <iostream>
#include<thread>
#include<mutex>
#include<list>
#include<condition_variable>
using namespace std;
class A
{
public:
void inQueue(void)
{
for(int i = 0; i<10000;i++)
{
cout<<"insert message : "<<i<<endl;
{
std::unique_lock<std::mutex> uniqueLock(mtx);
message.push_back(i);
}
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
}
void outQueue(void)
{
for(int i = 0; i<10000;i++)
{
if(!message.empty())
{
int cmd = 0;
{
std::unique_lock<std::mutex> uniqueLock(mtx);
cmd = message.front();
message.pop_front();
}
cout<<"out cmd is :"<<cmd<<endl;
}
else
{
cout<<"empty---------------i: "<<i<<endl;
}
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
}
private:
std::list<int> message;
std::mutex mtx;
};
int main()
{
A a;
std::thread th1(&A::inQueue,&a);
std::thread th2(&A::outQueue,&a);
th1.join();
th2.join();
return 0;
}
６）单例模式在线程中的使用
#include <iostream>
#include<thread>
#include<mutex>
using namespace std;
std::mutex mtxRes;
//单例目的：即使多个线程被创建，也要保证只创建一个对象，所以创建多线程创建对象时，要做互斥量条件判断！！！
class A
{
private:
A(){
cout<<"A conctructor---"<<endl;}
private:
static A* m_instance; //声明一个静态私有类指针变量
public:
static A* getInstance()
{
if(m_instance == nullptr) //多个线程，为了提升速度(双重锁定)
{
std::unique_lock<std::mutex> uniquelock(mtxRes);
if(m_instance == nullptr)
{
m_instance = new A();
static garb cl;//为了程序退出后，能够正常删除m_instance
}
}
return m_instance;
}
void test(void)
{
cout<<"test------"<<endl;
}
class garb //为了能正常delete m_instance，而设计的内部类
{
public:
~garb()
{
if(A::m_instance != nullptr)
{
delete A::m_instance;
A::m_instance = nullptr;
}
}
};
};
A* A::m_instance = nullptr;
void func(void)
{
cout<<"-----开始单例模式创建--------"<<endl;
A::getInstance()->test();
cout<<"-----单例模式创建完成--------"<<endl;
}
int main()
{
// A::getInstance()->test();
std::thread th1(func);
std::thread th2(func);
th1.join();
th2.join();
return 0;
}