多线程小节

void process(){}
std::thread measurement_process{process};
其中process为函数

Factor fac; 类
std::thread t1(fac); or
std::thread t1((Factor()));
若有参数传递
class Factor {
void operator()(std:string &msg){
msg = “*“;
}
};
main(){
std::string s=”i love u”;
std::thread t1((Factor()), std::move(s));
//把s移动到子线程，主线程就没有了
t1.join(); //t1子线程运行结束再进行主线程
//t1.attach() 主线程继续运行
std::thread t2 = std::move(t1);
t1.get_id();
//一线程移动到２线程，此时１为空
t2.join();
std::thread::hardware_concurreny();//返回一共能有多少线程
}

＃include
std::mutex mu;

mu.lock()
cout << << endl; //这里发生异常，将会永远锁住
mu.unlock()
所以使用
std::lock_guard guard(mu);
//当guard析构时，不管有没有异常都会解锁

死锁：
１）确保每个lock顺序相同
２）function1:
std::lock(m_mutex,m_mutex2);
std::lock_guard locker(m_mutex,std::adopt_lock);
std::lock_guard locker2(m_mutex2,std::adopt_lock);
function 2:
std::lock(m_mutex,m_mutex2);
std::lock_guard locker2(m_mutex2,std::adopt_lock);
std::lock_guard locker(m_mutex,std::adopt_lock);
这样即使顺序不同也不会死锁

std::unique_lock locker(m_mutex,std::defer_lock);//defer_lock默认下面不加锁
//…不加锁，需加lock()
locker.lock();
//…加锁
locker.unlock();
//unique可以被移动lock_guard不可移动和复制
std::unique_lock locker2= std::move(locker);
unique相对lock_guard更消耗计算机性能

std::once_flag m_flag;
std::call_once(m_flag, &{f.open(“log.txt”)})
lamda函数只被一个线程调用一次

include

std::condition_variable cond;

std::unique_lock locker(mu);
q.push_front();
locker.unlock();
cond.notify_one();　　　//cond.notify_all()激活所有等待线程

std::unique_lock locker(mu);
cond.wait(locker,{ return !q.empty();避免被自己解锁});　//解锁mu,等到上面//locker解锁之后再激活，加锁
q.pop_back();
locker.unlock();