c++11——多线程

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 << ".\n";

	//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() << "\n";
	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..\n";
		}else if(status == std::future_status::timeout){
			std::cout << "time out...\n";
		}
		else if (status == std::future_status::ready){
			std::cout << "ready!\n";
		}
	} while (status != std::future_status::ready);
	std::cout << "result is " << future.get() << std::endl;
	return 0;
}

执行结果为：