C++11中线程间的异步通信

于 2025-02-12 16:02:57 发布
阅读量978 收藏 14
点赞数 28
分类专栏： C++进阶教程 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TechNomad/article/details/145591399
版权

文章目录

一、std::promise 和 std::future 的基本概念

在C++11中，std::promise 和 std::future 是用于实现异步编程的重要工具。它们提供了一种机制，允许一个线程将值或异常传递给另一个线程，从而实现线程间的数据传递和同步。

std::promise:

  • 是一个模板类，用于存储一个值或异常
  • 可以通过 set_value() 设置值，或者通过 set_exception() 设置异常
  • 与 std::future 关联，用于将结果传递给其他线程。

std::future:

  • 是一个模板类，用于从 std::promise 中获取值或异常。
  • 可以通过 get() 方法获取结果。如果结果尚未准备好，get() 会阻塞当前线程，直到结果可用。
  • 只能获取一次结果，调用 get() 后，future 的状态会变为无效。

二、std::promise 和 std::future 的基本使用

以下是一个简单的示例，展示如何使用 std::promise 和 std::future 在线程间传递数据：

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

void task(std::promise<int> promise) {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
    promise.set_value(42); // 设置结果
}

int main() {
    std::promise<int> promise;
    std::future<int> future = promise.get_future(); // 获取与 promise 关联的 future

    std::thread t(task, std::move(promise)); // 启动线程，传递 promise

    std::cout << "Waiting for result..." << std::endl;
    int result = future.get(); // 阻塞等待结果
    std::cout << "Result: " << result << std::endl;

    t.join(); // 等待线程结束
    return 0;
}

使用 std::promise 传递异常：

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

void task(std::promise<int> promise) {
    try {
        throw std::runtime_error("An error occurred!"); // 抛出异常
    } catch (...) {
        promise.set_exception(std::current_exception()); // 捕获并传递异常
    }
}

int main() {
    std::promise<int> promise;
    std::future<int> future = promise.get_future();

    std::thread t(task, std::move(promise));

    try {
        int result = future.get(); // 尝试获取结果
        std::cout << "Result: " << result << std::endl;
    } catch (const std::exception &e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }

    t.join();
    return 0;
}

std::future 的其他用法
wait():

  • 阻塞当前线程，直到结果可用。
  • 不返回结果，仅用于同步。

wait_for() 和 wait_until():

  • 允许设置超时时间，避免无限期阻塞。
#include <iostream>
#include <future>
#include <chrono>

int main() {
    std::promise<int> promise;
    std::future<int> future = promise.get_future();

    std::thread t([&promise]() {
        std::this_thread::sleep_for(std::chrono::seconds(2));
        promise.set_value(100);
    });

    std::future_status status;
    do {
        status = future.wait_for(std::chrono::milliseconds(500)); // 等待 500ms
        if (status == std::future_status::timeout) {
            std::cout << "Still waiting..." << std::endl;
        }
    } while (status != std::future_status::ready);

    std::cout << "Result: " << future.get() << std::endl;

    t.join();
    return 0;
}

输出：
在这里插入图片描述
std::promise 和 std::future的使用细节
适用场景：

  • 线程间通信:一个线程计算结果，另一个线程获取结果。
  • 异步任务:将任务交给一个线程执行，主线程通过 future 获取结果。
  • 异常传递:将子线程中的异常传递到主线程。

注意事项：

  • std::future 只能获取一次结果:调用 get() 后，future 的状态会变为无效，再次调用会导致未定义行为。
  • std::promise 和 std::future 不可复制:只能通过 std::move 传递。
  • 线程安全:：std::promise 和 std::future 是线程安全的，可以在多线程环境中使用。

三、std::async的基本用法

在C++11中，std::async 是一个用于异步执行任务的函数模板。它提供了一种简单的方式来启动异步任务，并返回一个 std::future 对象，用于获取任务的执行结果。std::async 是 C++11 并发编程的重要工具之一，可以替代手动创建和管理线程的复杂性。

1. std::async 的基本概念

  • 异步执行:std::async 允许在后台异步执行一个函数或可调用对象，而不会阻塞当前线程。
  • 返回值:返回一个 std::future 对象，用于获取异步任务的结果。
  • 启动策略:可以通过启动策略控制任务的执行方式（立即启动、延迟启动等）。

2. std::async 的语法

#include <future>

template <class Function, class... Args>
std::future<std::result_of_t<Function(Args...)>> async(Function&& f, Args&&... args);

template <class Function, class... Args>
std::future<std::result_of_t<Function(Args...)>> async(std::launch policy, Function&& f, Args&&... args);

参数:

  • f: 要执行的函数或可调用对象。
  • args: 传递给函数的参数。
  • policy: 启动策略（可选）。

返回值:

  • 返回一个 std::future 对象，用于获取任务的结果。

3. 启动策略
std::async 支持两种启动策略，通过 std::launch 枚举指定：

  • std::launch::async:任务会在一个新线程中立即异步执行。
  • std::launch::deferred:任务会延迟执行，直到调用 std::future::get() 或 std::future::wait() 时才在当前线程中执行。
  • 默认策略:如果不指定策略，std::async 的实现可以选择 std::launch::async 或 std::launch::deferred，或者两者的组合。

4. std::async 的基本使用
以下是一个简单的示例，展示如何使用 std::async 异步执行任务并获取结果：

#include <iostream>
#include <future>
#include <chrono>

int task() {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
    return 42;
}

int main() {
    // 启动异步任务
    std::future<int> future = std::async(std::launch::async, task);

    std::cout << "Waiting for result..." << std::endl;
    int result = future.get(); // 阻塞等待结果
    std::cout << "Result: " << result << std::endl;

    return 0;
}

5. 使用 std::async 传递参数
std::async 可以传递参数给任务函数。以下是一个示例：

#include <iostream>
#include <future>

int add(int a, int b) {
    return a + b;
}

int main() {
    // 启动异步任务并传递参数
    std::future<int> future = std::async(std::launch::async, add, 10, 20);

    int result = future.get(); // 获取结果
    std::cout << "Result: " << result << std::endl;

    return 0;
}

6. 使用 std::async 处理异常
如果任务函数抛出异常，异常会被捕获并存储在 std::future 中。调用 future.get() 时，异常会重新抛出。

#include <iostream>
#include <future>
#include <exception>

int task() {
    throw std::runtime_error("An error occurred!");
    return 42;
}

int main() {
    std::future<int> future = std::async(std::launch::async, task);

    try {
        int result = future.get(); // 尝试获取结果
        std::cout << "Result: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }

    return 0;
}

7. 使用 std::async 的启动策略

#include <iostream>
#include <future>
#include <chrono>

int task() {
    std::cout << "Task running on thread: " << std::this_thread::get_id() << std::endl;
    return 42;
}

int main() {
    // 延迟启动任务
    std::future<int> future = std::async(std::launch::deferred, task);

    std::cout << "Main thread: " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));

    int result = future.get(); // 任务在当前线程中执行
    std::cout << "Result: " << result << std::endl;

    return 0;
}

8. std::async 的适用场景

  • 异步计算:将耗时的计算任务放到后台执行，避免阻塞主线程。
  • 并行任务:同时启动多个任务，充分利用多核 CPU。
  • 简化线程管理:替代手动创建和管理线程的复杂性。

9. 注意事项

  • std::future 的生命周期:确保 std::future 对象的生命周期足够长，以避免任务未完成时 future 被销毁。
  • 启动策略的选择:如果不指定策略，std::async 的行为可能因实现而异。如果需要明确的行为，应显式指定策略。
  • 性能开销:std::async 可能会创建新线程，带来一定的性能开销。对于非常小的任务，可能不适合使用。

四、std::packaged_task的基本用法

在C++11中，std::packaged_task 是一个模板类，用于将可调用对象（如函数、Lambda表达式等）包装成一个异步任务，并与 std::future 关联，以便在任务完成后获取结果。std::packaged_task 通常用于将任务与线程分离，使得任务可以在任意线程中执行，同时通过 std::future 获取任务的结果。

1. std::packaged_task 的基本概念

  • 任务包装器:std::packaged_task 是一个可调用对象的包装器，可以将函数、Lambda表达式等包装成一个任务。
  • 每个 std::packaged_task 都与一个 std::future 关联，用于获取任务的执行结果。
  • 线程分离:任务可以在任意线程中执行，而不需要直接与线程绑定。

2. std::packaged_task 的基本使用
以下是一个简单的示例，展示如何使用 std::packaged_task 包装任务并通过 std::future 获取结果：

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

int task() {
    std::this_thread::sleep_for(std::chrono::seconds(2)); // 模拟耗时操作
    return 42;
}

int main() {
    // 创建一个 packaged_task，包装任务函数
    std::packaged_task<int()> packaged_task(task);

    // 获取与任务关联的 future
    std::future<int> future = packaged_task.get_future();

    // 在另一个线程中执行任务
    std::thread t(std::move(packaged_task)); // packaged_task 不可复制，必须使用 std::move

    std::cout << "Waiting for result..." << std::endl;
    int result = future.get(); // 阻塞等待结果
    std::cout << "Result: " << result << std::endl;

    t.join(); // 等待线程结束
    return 0;
}

3. 使用 std::packaged_task 传递参数
std::packaged_task 可以包装带参数的任务。以下是一个示例：

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

int add(int a, int b) {
    return a + b;
}

int main() {
    // 创建一个 packaged_task，包装带参数的任务函数
    std::packaged_task<int(int, int)> packaged_task(add);

    // 获取与任务关联的 future
    std::future<int> future = packaged_task.get_future();

    // 在另一个线程中执行任务
    std::thread t(std::move(packaged_task), 10, 20); // 传递参数

    int result = future.get(); // 获取结果
    std::cout << "Result: " << result << std::endl;

    t.join(); // 等待线程结束
    return 0;
}

4. 使用 std::packaged_task 处理异常
如果任务函数抛出异常，异常会被捕获并存储在 std::future 中。调用 future.get() 时，异常会重新抛出。

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

int task() {
    throw std::runtime_error("An error occurred!");
    return 42;
}

int main() {
    std::packaged_task<int()> packaged_task(task);
    std::future<int> future = packaged_task.get_future();

    std::thread t(std::move(packaged_task));

    try {
        int result = future.get(); // 尝试获取结果
        std::cout << "Result: " << result << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Exception: " << e.what() << std::endl;
    }

    t.join();
    return 0;
}

5. 使用 std::packaged_task 重置任务
std::packaged_task 的 reset() 函数可以重置任务状态，使其可以重新执行。

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

int task() {
    static int count = 0;
    return ++count;
}

int main() {
    std::packaged_task<int()> packaged_task(task);

    // 第一次执行任务
    std::future<int> future1 = packaged_task.get_future();
    std::thread t1(std::move(packaged_task));
    t1.join();
    std::cout << "Result 1: " << future1.get() << std::endl;

    // 重置任务
    packaged_task.reset();
    std::future<int> future2 = packaged_task.get_future();
    std::thread t2(std::move(packaged_task));
    t2.join();
    std::cout << "Result 2: " << future2.get() << std::endl;

    return 0;
}

6. std::packaged_task 的适用场景

  • 任务队列:将任务包装成 std::packaged_task 并放入队列中，由线程池或其他线程执行。
  • 异步任务管理:将任务与线程分离，通过 std::future 获取结果。
  • 并行计算:将计算任务分发到多个线程中执行，并通过 std::future 收集结果。

7. 注意事项

  • std::packaged_task 只能移动（move），不能复制。
  • 确保 std::future 对象的生命周期足够长，以避免任务未完成时 future 被销毁。
  • std::packaged_task 本身不是线程安全的，需要在多线程环境中小心使用。
【5】c++多线程技术之线程间通信
以道御术
04-12 513
线程间通信是多线程编程中的一个重要概念，它指的是在一个程序中的多个线程之间传递信息或者同步执行的过程。在C++中，有多种方式可以实现线程间的通信。
windows C++进程间和线程间通信
wang010366的专栏
08-09 5080
Thank Swarajya Pendharkar and MSDN very much 进程间通信进程基本概念In computer science, inter-process communication or interprocess communication (IPC) refers specifically to the mechanisms an operating system p
10分钟，带你掌握C++多线程同步！
weixin_34018202的博客
04-25 1476
摘要：本文介绍了C++11中如何开启新线程，并详细讲解了线程的基础同步原语：mutex, lock_guard, unique_lock, condition variable和semaphore等。如何采用async, packaged_task和promise实现future同步机制？怎样处理spurious wakeup?本文以质数判定服务为例...
多线程编程之三——线程间通讯
抓狂的石头
06-28 3279
作者：韩耀旭七、线程间通讯　　一般而言,应用程序中的一个次要线程总是为主线程执行特定的任务,这样,主线程和次要线程间必定有一个信息传递的渠道,也就是主线程和次要线程间要进行通信。这种线程间的通信不但是难以避免的，而且在多线程编程中也是复杂和频繁的，下面将进行说明。 使用全局变量进行通信由于属于同一个进程的各个线程共享操作系统分配该进程的资源，故解决线程间通信最简单的一种方法
c++ 线程间通信方式
weixin_30527423的博客
04-28 525
一：两个进程间的两个线程通信，相当于进程间通信 二：一个进程中的两个线程间通信 　　通信方式： 1.互斥锁 　　mutex; 　　lock_guard (在构造函数里加锁，在析构函数里解锁） 　　unique_lock自动加锁、解锁 2.读写锁 　　shared_lock 3.信号量 　　c++11中未实现，可以自己使用mutex和conditon_varia...
C++的并发世界（十）——线程异步和通信
图像学习之旅
04-08 419
promise用于异步传输变量std::promise提供存储异步通信的值，再通过其对象创建的std::future异步获得结构。std::promise只能使用一次。void set_value(_Ty &&Val)设置传递值，只能用掉一次。
C++ 线程（串行 并行 同步 异步）详解
08-30
C++ 线程（串行 并行 同步 异步）详解 C++ 线程是指在程序中可以同时执行多个任务的技术，通过线程可以提高程序的执行效率和响应速度。在 C++ 中，线程可以分为串行线程和并行线程两种。 串行线程（Serial Thread...
C++ 多进程多线程间通信
最新发布
wy749929317的博客
07-05 2960
请注意，这里的互斥锁是在全局命名空间中创建的（通过前缀"Global\\"），这意味着它可以在系统范围内的任何进程中访问。这是必需的，因为我们的目标是让多个不同的进程能够识别并访问同一个互斥锁。请注意，我们使用了全局命名的信号量（通过前缀Global\），这意味着信号量在整个系统中都是可见的，可以被任何进程访问。特点：它是最快的进程间通信方式，避免了数据的拷贝，但共享内存需要解决并发访问和同步问题，常用的同步机制包括互斥锁（Mutexes）、信号量（Semaphores）和事件（Events）等。
C++11 多线程
09-23
#### 十四、C++线程类库参考 - **详细的C++11线程库文档**：包括所有相关类和函数的详细介绍，帮助开发者更好地理解和使用这些工具。 #### 结论 **C++11** 的多线程支持为开发者提供了一套强大的工具来构建高性能...
c++ 多线程编程之三----线程间通讯
04-23
c++ 多线程编程之三 线程间通讯 后面还有四哦
线程间通信方式3：消息传递方式
01-18
线程间通信方式3：消息传递方式的演示。采用计算演示线程的执行，并采用用户界面线程来实时显示执行的进度，线程间的通信方式采用了3种方式相结合，对多线程间的通信有比较好的学习和研究价值。
VS2017实现TCP socket多线程同步（C++）
05-23
包括TCP服务器客户端多线程通信同步程序（用select语句和WSAEVENT事件对象机制），基于Visual Studio2017实现发，已编译测试过，用到的朋友记得关闭SDL检查
C++线程通信
weixin_43803780的博客
05-03 1458
通常与互斥锁配合使用，通过`std::condition_variable::wait()`、`std::condition_variable::notify_one()`和`std::condition_variable::notify_all()`进行线程间的同步与唤醒。- 使用`std::lock_guard`或`std::unique_lock`自动管理锁的生命周期，或者直接使用`std::mutex::lock()`和`std::mutex::unlock()`手动控制加锁和解锁。
C++11线程间通信
weixin_41157881的博客
07-10 333
利用c++11的future和promise可以进行线程间的通信 #include #include #include #include using namespace std; std::promise promis; int main() { std::futurestd::string fuResult = promis.get_future(); auto t_cb = { cout &...
143-C++11线程间的同步通信(生产者-消费者模型)
Edward_LF的博客
05-03 1434
多线程编程两个问题 1、线程间的互斥 竞态条件： 多线程执行的结果是一致的，不会随着CPU对线程不同的调用顺序，而产生不同的运行结果。 发生竞态条件的代码段，称为临界区代码段（只有一个线程可以进来），保证临界区代码段原子操作，通过线程互斥锁mutex，也可以使用轻量级的无锁实现CAS。 C++11的mutex底层实现： 使用strace ./a.out跟踪代码，使用C++11提供的mutex，Linux底层使用的也是自己的pthread_mutex互斥锁。 2、线程间的同步通信 线程间不通信的话，每个
11_C++多线程及线程间通信
卡木
08-08 7048
参考： https://m.imooc.com/article/289630 C++11 标准库新引入的线程库 https://www.jianshu.com/p/e5a3498ba930 （一）多线程编程 #include <iostream> #include <thread> #include <mutex> #include <condi...
C++ 线程间通信
chuuya1的博客
03-10 540
async、promise、future
c++线程间通信
不爱吃鱼的程序猿
07-17 1720
c++线程间通过PostThreadMessage和GetMessage函数进行通信，下面用代码演示两个线程间的通信： // ConsoleApplication1.cpp : 定义控制台应用程序的入口点。 // #include <stdio.h> #include<windows.h> using namespace std; DWORD WINAPI ThreadFun1(LPVOID param); DWORD WINAPI ThreadFun2(LPVOID para
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值