1 线程

std::thread
注意点：

• 线程退出，采用join时需要利用：joinable()进行判断当前线程是否安全。
• 线程如果采用detach()，线程将分离，join将无法捕获，线程将独立自动退出。

2 锁

std::mutex
注意点：

• 独占的互斥量，不能递归使用。
• 不建议使用mutex直接锁，主要是释放锁容易遗忘造成死锁

建议使用：lock_guard或者unique_lock上锁
注意点：

• 这个锁构造创建，析构释放，栈上锁可以自动释放
• unique_lock可以进行临时解锁和再上锁，如在构造对象之后使用lck.unlock()就可以进行解锁，
  lck.lock()进行上锁，而不必等到析构时自动解锁。

std::lock_guard<std::mutex> lck (mtx);
std::unique_lock<std::mutex> lck (mtx);

3 条件变量

std::condition_variable_any和std::condition_variable
注意点：

• condition_variable在wait的时候需要和unique_lock锁配合使用
• condition_variable_any等待的时候传入的是mutex锁先解锁再等待

//condition_variable和unique_lock使用传入的是unique_lock对象进行解锁后再等待
std::condition_variable _notEmpty;
std::unique_lock<std::mutex> locker(_mutex);
_notEmpty.wait(locker, [this]{return !_queue.empty(); });
//condition_variable_any和lock_guard使用直接传如mutex进行解锁后再等待
std::condition_variable_any _notEmpty;
std::lock_guard<std::mutex> locker(_mutex);
_notEmpty.wait(_mutex);

4 原子操作

std::atomic
注意点：

• 初始化需要利用构造函数进行初始化
• 在单例模式中对象创建中，主要是解决cpu reorder问题

std::atomic<int> foo(0); // 准确初始化
//设置原子操作对象
foo.store(x,std::memory_order_relaxed); // set value atomically
//获取原子操作对象
x = foo.load(std::memory_order_relaxed); // get value atomically

5 异步操作

std::future
注意点：

• future使用的时机是当你不需要立刻得到一个结果的时候，你可以开启一个线程帮你去做一项任务，并
  期待这个任务的返回

#启动异步执行函数do_some_things
std::future<decltype (do_some_things())> result =std::async(do_some_things);
#本地处理函数：do_other_things
do_other_things();
#等待异步事件返回结果
std::cout << "result: " << result.get() << std::endl;

std::packaged_task
*注意点：

• 简化任务，类似取别名
• 必须要让任务执行，否则在get()获取future的值时会一直阻塞

int add(int a, int b){...
}
//为add取名task，或者是理解为加入一个容器中
std::packaged_task<int(int, int)> task(add);
do_other_things();
std::future<int> result = task.get_future();
//必须要让任务执行
task(1, 1); 
std::cout << result.get() << std::endl;

函数绑定

std::function
注意点：

void printA(int a){...}
//函数绑定
std::function<void(int a)> func;
func = printA;
func(2); 
//成员函数绑定 
std::function<void(const Foo&,int)> fplay= &Foo::printA;

std::bind
注意点：

• 可将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。

auto f1 = std::bind(funA,1,2,3); //表示绑定函数 fun 的第一，二，三个参数值为： 1 2 3
f1(); //print: x=1,y=2,z=3
//支持变参
auto f2 = std::bind(fun_1, placeholders::_1,placeholders::_2,3);//表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f2 的第一，二个参数指定
f2(1,2);//print: x=1,y=2,z=3