c++ 多线程

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <thread>
#include <iostream>

std::thread t1(func_my); //创建线程  func_my 是个函数 也可以是个类   参数直接     

std::thread t1(func_my,"wowoow");  //有参数时

std::thread t1(func_my2,std::move(&s1));//std::move  增加性能 安全高效

class A{

}

A a;

std::thread t1(a)；//传递a的拷贝给子线程

std::thread t2(std::ref(a));//传递a的引用

std::thread t3(std::move(a));// 将a从主线程中传入子线程   a在主线程中将无效

std::thread t4(A());  //传递一个临时创建的A对象

std::thread t5（[](int x){ });  //用lamda函数

std::thread t6(&A::f,a);    //对象a的拷贝 的成员函数

std::thread t6(&A::f,&a);    //a的地址 的成员函数

t1.detach();  主线程不用等待t1结束再运行
if (t1.joinable()) {
t1.join();  //之后 主线程等待t1结束再运行
}

//一个线程  只能 被 detach  或者join  一次

//避免主线程异常 t1.join() 执行前 t1 被销毁

std::thread t1(func_my);
try {
for (int i = 0; i < 1000; i++) {
log("%d", i);
}

}
catch(...){
t1.join();
throw;   
}
t1.join();

//参数是个类时

class class_my {
public:
void operator()() {
//for (int i = 0; i < 1000;i++) {
log("%d",10000);
// }
}
};

class_my myClass;    //需要先实例化
std::thread t1(myClass);

       //或者

std::thread t2((class_my()));   

引用传递

func(std::ref(s));  

std::to_string()  //转为string  c++11

 std::move  移动!!!!!!!!

std::thread t2 = std::move(t1);//线程移动     t1会空

std::this_thread::get_id() ； //获取线程id

t1.get_id()；

std::thread::hardware_concurrency()；//cpu线程数

//互斥

#include <mutex>
std::mutex mutex;
int add(int v1, int v2) {
return v1 + v2;
}
int addnum(int v1, int v2) {
std::lock_guard<std::mutex> guard(mutex);    // 这个不需要使用unlock   避免异常被永久锁定  不推荐使用  mutex.lock(); mutex.unlock();   //  解锁
        int j   = add(v1,v2);
return j;
}
void func_my() {
int j = 0;
for (int i = 0; i < 10;++i) {
j =addnum(i, j);
}
log("%d",j);
}

  

//多个mutex 避免死锁

//写法  多个锁时 注意锁定顺序避免死锁

std::mutex mutex1;
std::mutex mutex2;

std::lock(mutex1, mutex2);//锁1再锁2 制定锁顺序
std::lock_guard<std::mutex> lockg1(mutex, std::adopt_lock);//std::adopt_lock 表示已经锁定 析构时释放
std::lock_guard<std::mutex> lockg2(mutex2, std::adopt_lock);

unique_lock 可以有unlock();  //比lock_guard 更耗性能

std::unique_lock<std::mutex> unilock(mutex);

std::unique_lock<std::mutex> unilock(mutex,std::defer_lock);//推迟锁定    可以有（也可以没有） unilock.lock();

unilock.unlock();

std::unique_lock<std::mutex>lock2 = std::move(unilock); //把unilock控制权转移到lock2

//luamda表达式里内容只会被一个线程调用一次

std::once_flag flag;
void addnum() {
std::call_once(flag, [&]() {MessageBox("221122", "222"); });
}

//线程休眠1秒

std::this_thread::sleep_for(std::chrono::seconds(1));

std::this_thread::sleep_for(std::chrono::milliseconds(10));

#include<condition_variable>
std::condition_variable cond;

std::mutex mutex;

void func1(){

std::unique_lock<mutex>  locker(mutex);

locker.unlock();
cond.notify_one();//会激活等待这个条件的线程  cond.notify_all(); //激活所有等待的线程
}

void func2{
std::unique_lock<mutex>  locker(mutex);
cond.wait(locker,[](){ return true;});//会先解锁   再去休眠 激活时再锁定 （会出现未激活   后面 lamda 返回true  才会继续执行下去）

}

//父线程区获取子线程的变量值

#include<future>

int addnum(int n,int &x) {
int res = 1;
for (int i = n; i > 1; i--) {
x *= i;
}
return x;
}

   int x = 10; std::launch::anync 会创建线程
   std::future<int> fu=  std::async(addnum, 10, std::ref(x)); //第一个参数是( std::launch::deferred,addnum, 10, std::ref(x))  不创建线程 延期启动
   int xxx =fu.get();    //会等待上面子线程结束 返回结果  只能被调用一次

//子线程获取父线程的 变量

#include<future>
int addnum(std::future<int>&x) {
int res = 1;
int n = x.get();       //获取值  没有setvalue 会异常
for (int i = n; i > 1; i--) {
n *= i;
}
return n;
}

 std::promise<int> p;   //声明
 std::future<int> fu2= p.get_future();  //定义

 std::future<int> fu=  std::async(std::launch::async|std::launch::deferred,addnum, std::ref(fu2));//!!!!!!!!!!
 p.set_value(4);//设置值

   int xxx =fu.get();//子向父取回值

//多个子节点时 上面更改

int addnum(std::share_future<int>x) {

std::shared_future<int> sf = fu2.share();//

//多个子

std::future<int> fu=  std::async(std::launch::async|std::launch::deferred,addnum, sf);

std::future<int> fu2=  std::async(std::launch::async|std::launch::deferred,addnum, sf);

p.set_value(4);

//packaged_task

   std::packaged_task<int()> t(std::bind(addnum,6));
   std::future<int> ret = t.get_future();
   t();
   int value = ret.get();

//时间限制

 std::chrono::steady_clock::time_point tp = std::chrono::steady_clock::now() +
  std::chrono::milliseconds(4000);
   std::this_thread::sleep_until(tp);




   std::mutex mutex;
   std::unique_lock<std::mutex> locker(mutex);
   locker.try_lock_for(std::chrono::milliseconds(300));
   locker.try_lock_until(tp);






   std::condition_variable cond;
   cond.wait_for(locker, std::chrono::milliseconds(300));
   cond.wait_until(locker, tp);




   std::promise<int> p;
   std::future<int> f = p.get_future();
   f.wait_for(std::chrono::milliseconds(300));
   f.wait_until(tp);