c++11中增加了线程以及线程相关的类，很方便的支持了并发编程。
1. 线程
线程创建
使用std::thread创建线程，提供线程函数或者函数对象即可，并且可以指定线程函数的参数。
#include<thread>
void func(int a){
cout << "param= " << a << endl;
}
int main(){
std::thread t(func, 10); //创建线程使用线程函数以及函数参数
t.join(); //等待线程函数执行完毕
return 0;
}
可以通过std::bind或lambda表达式来创建线程：
void func(int a,int b){
cout << "a = " << a << ", b = " << b << endl;
}
int main(){
std::thread t1(std::bind(func, 1, 2));
std::thread t2([](int a, int b){cout << "a = " << a << ", b = " << b << endl;}, 1,2);
return 0;
}
join 和 detach
如果希望在主线程中等待其他线程终止，使用join来实现，t.join()阻塞等待线程t结束，才能继续往下执行；
如果不希望线程被阻塞执行，可以调用 t.detach() 方法，将线程和线程对象分离，分离之后，线程单独执行，由系统回收资源。通过detach，线程和线程对象分离，让线程作为后台线程执行，当前线程也不会被阻塞。但需要注意，detach之后，就无法再和线程发生联系，不能通过join再阻塞等待线程，线程何时执行完我们也无法控制。
若在创建子线程的线程中，既没有执行对子线程进行join也没有进行detach，则有可能出现线程对象在线程函数结束之前就失效，从而出错。
int main(){
std::thread t(func);
t.detach();
//做其他事情....
return 0;
}
线程生命期
std::thread在出了作用域之后就会被析构，这是如果线程函数还没有被执行完，就会发生错误。因此，需要保证线程函数的生命周期在线程变量 std::thread的生命周期之内，这可以通过join阻塞等待实现。
线程不能被复制，但可以移动，比如：
#include<thread>
void func(){
//do some work
}
int main(){
std::thread t(func);
std::thread t1(std::move(t));
t.join();
t1.join();
return 0;
}//线程被移动(std::move)后，线程对象t就不代表任何线程了。
线程基本用法
1. 获取当前信息
void func(){
}
int main(){
std::thread t(func);
cout << t.get_id() << endl; //获取线程id
cout << std::thread::hardware_concurrency() << endl; //获取cpu核数
return 0;
}
2. 线程休眠
void f(){
std::this_thread::sleep_for(std::chrono::seconds(3)); //当前线程休眠3秒钟
}
2. 互斥量
互斥量是一种同步原语，是一种线程同步的手段，用来保护多线程同时访问的共享数据。
c++11中提供了四种语义的互斥量(mutex):
std::mutex 独占的互斥量，不能递归使用
std::timed_mutex 带超时的独占互斥量，不能递归使用
std::recursive_mutex 递归互斥量，不带超时功能
std::recursive_timed_mutex 带超时的递归互斥量
std::mutex
std::mutex g_lock;
void func(){
g_lock.lock();
std::cout << "entered thread " << std::this_thread::get_id() << std::endl;
std::this_thread::sleep_for(std::chrono::seconds(1));
std::cout << "leave thread " << std::this_thread::get_id() << endl;
g_lock.unlock();
}
std::recursive_mutex
递归锁允许同一线程多次获得该互斥锁，可以用来解决同一线程需要多次获取互斥量时死锁的问题。但尽量不要使用递归锁，因为：
（1）需要用到递归锁定的多线程往往本身是可以简化的
（2）递归锁比起非递归锁，效率会低一些
（3）递归锁虽然允许同一线程多次获得同一个互斥量，可重复获得的最大次数并未具体说明，一旦超过次数，再对lock进行调用就会抛出std::system错误。
std::timed_mutex
std::timed_mutex是超时的独占锁，主要用于在获取锁时增加超时等待功能，在超时时间之内如果获得锁，则继续，否则，返回超时，并不再阻塞。
std::time_mutex 使用 try_for_lock(timexx)来尝试获取锁，在超过timexx时间仍未获得锁，则返回超时。
std::time_mutex mut;
void work(){
std::chrono::milliseconds timeout(100);
while(true){
if(mut.try_lock_for(time_out)){
std::cout << std::this_thread::get_id() << " :do work with the mutex" << endl;
std::chrono::milliseconds sleepDuration(250);
std::this_thread::sleep_for(sleepDuration);
mut.unlock();
}else{
std::cout << "time out for get lock" << endl;
}
}
}
lock_guard
lock_guard利用RAII机制，防止忘记unlock或者发生异常时无法unlock造成程序死锁。
std::mutex mut;
void func(){
std::lock_guard<std::mutex> guard(mut);
xxxx
}
3. 条件变量
条件变量能阻塞一个或多个线程，直到收到另外一个线程发出的通知或者超时，才会唤醒当前阻塞的线程。条件变量需要和互斥量配合起来使用一。c++11提供了两种条件变量： condition_variable, 配合std::unique_lock<std::mutex>进行wait操作 condition_variable_any，和任意带有lock，unlock语义的mutex搭配使用，比较灵活，
但效率比condition_varaible略低
void Put(const T& x){
std::lock_guard<std::mutex> locker(m_mutex);
while(IsFull()){
cout << "缓冲区满，需要等待..." << endl;
m_notFull.wait(m_mutex);
}
m_queue.push_back(x);
m_notEmpty.notify_one();
}
void Take(T& x){
std::lock_guard<std::mutex> locker(m_mutex);
while(IsEmpty()){
cout << "缓冲区空，需要等待...." << endl;
m_notEmpty.wait(m_mutex);
}
x = m_queue.front();
m_queue.pop_front();
m_notFull.notify_one();
}
std::list<T> m_queue;
std::mutex m_mutex;
std::condition_variable_any m_notEmpty;
std::condition_variable_any m_notFull;
4. 原子变量
c++11提供了一个原子类型 std::atomic< T>，可以使用任意类型作为模板参数，c++11内置了整型的原子变量，可以更方便的使用原子变量，使用原子变量就不需要使用互斥量来保护该变量了。
#include<atomic>
struct AtomicCounter{
std::atomic<int> value;
void inc(){
++value;
}
void dec(){
--value;
}
int get(){
return value.load();
}
};
5. call_once/once_flag使用
为了保证在多线程环境中某个函数仅被调用一次，或者某个变量仅仅被初始化一次，可以使用 std::call_once来保证函数在多线程环境中只被调用一次。使用std::call_once时，需要一个once_flag作为call_once的入参。
std::once_flag flag;
void do_once(){
std::call_once(flag, [](){ std::cout << "called once" << endl;});
}
6. 异步操作
c++11中提供了异步操作相关的类，主要有 std::future, std::promise, std::package_task. std::future 作为异步结果的传输通道，很方便的获取线程函数的返回值； std::promise用来包装一个值，将数据和future绑定起来，方便线程赋值；std::package_task用来包装一个可调用对象，将函数和future帮顶起来，以便异步调用。
std::future 获取线程函数返回值
c++ thread库提供了future用来访问异步操作的结果，future提供了获取异步操作结果的通道，可以以同步等待的方式来获取结果，可以通过查询future的状态(future_status)来获取异步操作的结果。
future_status == Deferred 异步操作还没开始
future_status == Ready 异步操作已经完成
future_status == Timeout 异步操作超时
std::future_status st;
do{
st = future.wait_for(std::chrono::seconds(1));
if(st == std::future_status::deferred){
//还没开始
}else if(st == std::future_status::timeout){
//超时
}else if(st == std::future_status::ready){
//ready
}
}while(st != std::future_status::Ready);
获得future结果的三种方式： get, wait, wait_for， 其中get等待异步操作的结果并返回结果；wait只是等待异步操作完成，没有返回值；wait_for是超时等待返回的结果。
std::promise 协助线程赋值的类
std::promise 将数据和future绑定起来，为获取线程函数中的某个值提供便利，在线程函数中为外面传进来的promise赋值，在线程函数执行完成之后就可以通过promise的future获取该值。
std::promise<int> pr;
std::thread t([](std::promise<int>& p)
{ p.set_value_at_thread_exit(9);}, //在线程函数中为promise赋值
std::ref(pr)); //线程函数的参数，使用引用
std::future<int> f = pr.get_future(); //获取promise的future
auto r = f.get(); //利用get等待异步操作的结果（阻塞）
std::packaged_task 可调用对象的包装类
std::packaged_task可以将函数等可调用对象和future绑定起来，以便异步调用。
std::packaged_task<int()> task([]{return 7;});
std::thread t1(std::ref(task));
std::future<int> f1 = task.get_future();
auto r1 = f1.get();
std::promise, std::packaged_task, std::future三者之间的关系
std::future提供了一个访问异步操作结果的机制，它和线程是一个级别的，属于低层次的对象。std::future之上的高一层为 std::packaged_task和std::promise, 他们内部都有future以便访问异步操作的结果，std::packaged_task包装的是一个异步操作，而std::promise包装的是一个值，都是为了方便异步操作。
future被promise和packaged_task用来作为异步操作或异步结果的连接通道，用std::future和std::shared_future来获取异步调用的结果。future不可拷贝，只能移动，shared_future可以拷贝，当需要将future放到容器中则需要用shared_future。
#include<iostream>
#include<utility>
#include<future>
#include<vector>
#include<thread>
int func(int x){
return x*x;
}
int main(){
std::packaged_task<int(int)> tsk(func);
std::future<int> fut = tsk.get_future();
std::thread(std::move(tsk), 2).detach();
int value = fut.get();
std::cout << "The result is " << value << ".
";
//std::future不可复制，无法放到容器中，需要用shared_future
std::vector<std::shared_future<int>> v;
std::shared_future<int> f = std::async(std::launch::async, [](int a, int b){ return a + b; }, 2, 3);
v.push_back(f);
std::cout << "The shared future result is " << v[0].get() << "
";
return 0;
}
std::async 线程异步操作函数
std::async比std::promise, std::packaged_task, std::thread更高一层，可以用来直接创建异步的task, 异步任务返回的结果也保存在future中，当需要获取异步任务的结果时，只需要调用future.get() 方法即可，如果不关注异步任务的结果，只是简单的等待任务完成的话，则调用 future.wait()方法。
std::async(std::launch::async | std::launch::deferred, f, args....)，第一个参数是线程创建的策略，默认策略为 std::launch::async。
std::launch::async 在调用 async时就开始创建线程
std::launch::deferred 延迟加载方式创建线程。调用 async时不创建线程，直到调用了future的get或者wait方法时才创建线程。
#include<iostream>
#include<thread>
#include<future>
#include<utility>
int main(){
std::future<int> f1 = std::async(std::launch::async, [](){
return 8;
});
std::cout << f1.get() << std::endl;
std::future<void> f2 = std::async(std::launch::async, [](){
std::cout << 8 << std::endl;
});
f2.wait();
std::future<int> future = std::async(std::launch::async, [](){
std::this_thread::sleep_for(std::chrono::seconds(3));
return 8;
});
std::cout << "waiting ... " << std::endl;
std::future_status status;
do{
status = future.wait_for(std::chrono::seconds(1));
if (status == std::future_status::deferred){
std::cout << "deferred..
";
}else if(status == std::future_status::timeout){
std::cout << "time out...
";
}
else if (status == std::future_status::ready){
std::cout << "ready!
";
}
} while (status != std::future_status::ready);
std::cout << "result is " << future.get() << std::endl;
return 0;
}
执行结果为： 