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;

}

执行结果为： 

最新文章

  1. keepalived从机接管后主机恢复不抢占VIP
  2. hihocoder-1014 Trie树
  3. 使用xib文件创建集合类单元格
  4. inline-block的垂直居中
  5. pycharm 修改新建文件时的头部模板(默认为__author__=&#39;...&#39;)
  6. Visual Studio Code+phpstudy(WampServer、LNMP...)为小白打造PHP开发环境
  7. 明星单品tab
  8. Excel读写
  9. 四、XML语言学习（2）
  10. linux设置静态ip地址
  11. [个人项目] 使用 Vuejs 完成的音乐播放器
  12. 事件触发器-----dispatchEvent
  13. OO模式-Singleton
  14. hadoop 配置文件简析
  15. spring4声明式事务--01注解方式
  16. 关于“scrum站立会议”
  17. git学习（6）多人协作
  18. 「6月雅礼集训 2017 Day7」电报
  19. [转]在SSIS中，使用“包配置”时的常见错误与解析
  20. hive 字符集问题 报错 Execution Error, return code 1 from org.apache.hadoop.hive.ql.exec.DDLTask. MetaException(message:For direct MetaStore DB connections,

热门文章

  1. 用sp_lock诊断SQL Sever的死锁问题
  2. C++代码优化方法总结
  3. 点滴积累【C#】---抓取页面中想要的数据
  4. linux kill 关闭进程命令
  5. iPhone How-to：如何调整UIView的Z-Order
  6. Netty的ByteBuf
  7. POJ - 3264 Balanced Lineup (RMQ问题求区间最值)
  8. Spring学习10-SpringMV核心组件2及SpringMVC项目示例
  9. javac使用笔记
  10. java:常用的两种设计模式（单例模式和工厂模式）