C++ 线程间通信

一、async

        1、头文件#include <thread>

        async()会自动创建一个线程去执行函数,返回类型为future。

        函数原型:


//(C++11 起) (C++17 前)
template< class Function, class... Args>
std::future<std::result_of_t<std::decay_t<Function>(std::decay_t<Args>...)>>
    async( Function&& f, Args&&... args );
 
//(C++11 起) (C++17 前)
template< class Function, class... Args >
std::future<std::result_of_t<std::decay_t<Function>(std::decay_t<Args>...)>>
    async( std::launch policy, Function&& f, Args&&... args );

第一个参数是线程创建的策略:

std::launch::async:在调用async就开始创建线程。
std::launch::deferred:延迟加载方式创建线程。调用async时不创建线程,直到调用了future的get或者wait时才创建线程。
默认策略是:std::launch::async | std::launch::deferred

二、future

        使用future可以拿到异步线程函数的返回值。

        future不支持拷贝构造,只支持移动构造,只允许一个future对象有权限获得结果。

        成员函数:

get()会释放原来的指针:

想要实现共享,需要用shared_future

      _Res
      get()
      {
        typename _Base_type::_Reset __reset(*this);
        return std::move(this->_M_get_result()._M_value());
      }
get()阻塞,直到线程函数执行完毕,返回线程函数返回值。get函数会释放future绑定的对象。
wait()在线程函数完成前一直阻塞。
wait_for()等待future对象的异步线程在一段时间段内是否执行完毕,返回future_state。阻塞
wait_until()等待future对象的异步线程在一个时间点是否执行结束,返回future_state。阻塞
share()获取std::future的所有权,移动语义
valid()判断该future对象是否有效

future_state:

deferred异步操作还未开始
ready异步操作已经完成
timeout异步操作超时,主要用于std::future<T>.wait_for()

三、promise

        promise可以保存template<typename T>类型的对象,该值可以被future对象读取(该future对象可能在另一个线程中),是一种线程同步的手段。

        promise只能被set一次。

        promise和future类似于消息的管道,但是是一次性的。

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++线程间通信可以使用互斥锁(mutex)、条件变量(condition variable)等机制来实现。下面是一个简单的例子: ```c++ #include <iostream> #include <thread> #include <mutex> #include <condition_variable> std::mutex mtx; std::condition_variable cv; bool ready = false; void funcA() { // 这里做一些耗时的操作 std::this_thread::sleep_for(std::chrono::seconds(1)); // 加锁 std::unique_lock<std::mutex> lck(mtx); // 设置 ready 标志位为 true ready = true; // 通知等待的线程 cv.notify_all(); } void funcB() { // 加锁 std::unique_lock<std::mutex> lck(mtx); // 等待 ready 标志位为 true cv.wait(lck, []{ return ready; }); // ready 标志位为 true 时执行下面的代码 std::cout << "Hello, world!" << std::endl; } int main() { // 创建两个线程 std::thread t1(funcA); std::thread t2(funcB); // 等待两个线程结束 t1.join(); t2.join(); return 0; } ``` 其中,`funcA` 线程会在执行完一些耗时的操作后设置 `ready` 标志位为 true,并通知等待的线程。`funcB` 线程会等待 `ready` 标志位为 true 后输出一条消息。 在这个例子中,我们使用了一个互斥锁和一个条件变量来实现线程间通信。`std::unique_lock` 是一个 RAII 封装的互斥锁,它可以自动释放锁。`std::condition_variable` 是一个条件变量,它可以在等待时自动释放锁,并在通知时重新获取锁。在等待时,`cv.wait(lck, predicate)` 会释放锁并等待条件变量被通知。`predicate` 是一个可调用对象,用于判断条件是否满足。在通知时,`cv.notify_all()` 会通知所有等待的线程,并重新获取锁。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值