c++11 condition_variable && future

条件变量std::condition_variable用于多线程之间的通信，它可以阻塞一个或同时阻塞多个线程。std::condition_variable需要与std::unique_lock配合使用 

#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>
#include <unistd.h>

class application {
    std::mutex              _mutex;
    std::condition_variable _cv;
    bool                    _dataLoaded;

public:
    application()
    {
        _dataLoaded = false;
    }

    void loadData()
    {
        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << "\n";
        std::this_thread::sleep_for(std::chrono::seconds(1));
        //锁定数据
        std::lock_guard<std::mutex> lock(_mutex);
        _dataLoaded = true;
        _cv.notify_one();
    }

    bool isDataLoad()
    {
        return _dataLoaded;
    }

    void mainTask()
    {
        std::cout << __FILE__ << __FUNCTION__ << __LINE__ << "\n";
        std::unique_lock<std::mutex> lock(_mutex);
        _cv.wait(lock, std::bind(&application::isDataLoad, this));
        /**
         *  开始等待条件变量得到信号 wait()将在内部释放锁，并使线程阻塞
         *  一旦条件变量发出信号，则恢复线程并再次获取锁，检测条件是否满足，满足go on，不满足，再次进入wait()
         */
        std::cout << "do processing on loaded data\n";
    }
};

int condition_variable_main()
{
    application app;
    std::thread th1(&application::mainTask, &app);
    std::thread th2(&application::loadData, &app);
    std::cout << __FILE__ << __FUNCTION__ << __LINE__ << "\n";
    sleep(1);
    th1.join();
    th2.join();
    return 0;
}

std::future 是一个类模板，其对象来存储未来值，通过get返回成员函数实现。如果get函数没有值将会阻塞。 

#include <future>
#include <iostream>
#include <thread>

void initiazer(std::promise<int>* promObj)
{
    std::cout << "Inside thread\n";
    promObj->set_value(35);
}

/**
 *  std::future 是一个类模板，其对象来存储未来值，通过get返回成员函数实现。如果get函数没有值将会阻塞。
 *
 *  std::future 和std::promise 对象与其管理的std::future 对象共享数据
 *  std::promise 对象在赋值之前被销毁，那么管理std::future的对象将会抛出异常
 *
 *  std::promise 可以保存一个类型为T的值，该值可以被future对象获取（可能在另外一个线程中），因此promise也提供了一种线程同步手段
 */
int future_main()
{
    std::promise<int> promiseObj;
    std::future<int>  futureObj = promiseObj.get_future();  // promise所管理的std::future对象

    std::thread th(initiazer, &promiseObj);
    std::cout << futureObj.get() << "\n";  //这里会阻塞，直到get有值可读
    th.join();

    return 0;
}