C++开发基础之异步编程模式

最新推荐文章于 2024-09-05 07:45:51 发布
最新推荐文章于 2024-09-05 07:45:51 发布
阅读量1.6k 收藏 28
点赞数 31
分类专栏： C++开发基础 文章标签： c++ 服务器 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/houbincarson/article/details/136338622
版权

1.前言

异步编程模式是现代C++开发中不可或缺的一部分。在处理IO密集型或者长时间运行的任务时，异步编程可以提高程序的响应性和吞吐量。异步编程模式通常适用于以下场景：

1. 需要执行耗时的 I/O 操作：例如读取文件、数据库操作、网络请求等，这些操作通常需要花费较长时间。如果使用同步方法，程序将会被阻塞，无法响应其他操作。而使用异步编程模式，可以在这些操作执行过程中继续处理其他任务，从而提高程序的并发性能和响应能力。

2. 需要执行计算密集型操作：虽然异步编程通常与 I/O 操作相关联，但它也可以用于执行计算密集型操作，例如图像处理、科学计算等。在这种情况下，异步编程可以帮助程序更好地利用多核处理器等硬件资源，加快计算速度。

3. 需要处理大量的并发请求：例如 Web 服务器、消息队列等，这些应用程序需要同时处理大量的请求，如果采用同步方式，程序将无法满足高并发的需求。而使用异步编程模式，可以充分利用系统资源，提高并发性能和可扩展性。

2.异步编程模式

  1. 回调函数（Callbacks）:
    回调函数是异步编程最基本的形式之一。当一个操作完成后，它会调用一个预定义的回调函数来通知程序，以便继续执行其他操作。在C++中，回调函数可以使用函数指针、std::function或者Lambda表达式来定义。

  2. Future/Promise:
    Future/Promise是一种更高级别的异步编程模式，它允许程序等待异步操作完成并获取结果。在C++中，可以使用std::future和std::promise来实现Future/Promise模式。

  3. 协程（Coroutines）:
    协程是一种轻量级的线程，它可以在同一线程内切换上下文并暂停/恢复执行。它可以用于实现高效的异步编程和状态机。在C++20中，协程已经成为了语言的一部分，并且可以使用co_await关键字来等待异步操作的完成。

  4. 异步/await（C++20）:
    异步/await是一种与协程相关的模式，它允许程序以自然的顺序编写异步代码。在C++20中，可以使用co_await关键字来等待异步操作的完成，并使用co_return关键字来返回异步操作的结果。

  5. 线程池（Thread Pool）:
    线程池是一种常见的并发模式，它可以提高程序的性能和资源利用率。一个线程池包含多个线程，在程序需要执行异步操作时，可以将任务提交到线程池中，以便在其中的一个线程上执行。在C++中，可以使用std::thread或者第三方库来实现线程池。

  6. Actor 模型:
    Actor模型是一种基于消息传递的并发模型，它允许多个独立的Actor同时运行，并通过消息进行通信。每个Actor都拥有自己的状态和行为，并且可以响应接收到的消息。在C++中，可以使用第三方库来实现Actor模型。

  7. Reactive Extensions:
    Reactive Extensions是一种基于事件流的编程模型，它允许程序以声明性的方式处理数据流。在C++中，可以使用rxcpplib或者其他第三方库来实现Reactive Extensions。

  8. 数据流处理框架:
    数据流处理框架是一种基于管道和过滤器的编程模型，它允许程序以可组合的方式处理数据流。在C++中，可以使用rxcpp或者其他第三方库来实现数据流处理框架。

3.各个模式特点

以下是C++开发中常见的异步编程模式，这些模式各有特点，可以根据具体需求选择适合的模式。

序号异步编程模式描述优势缺点适用场景学习曲线平台支持可读性性能
1回调函数（Callbacks）通过回调函数来处理异步操作完成后的结果和错误直接，易于理解可能导致回调地狱（callback hell），难以维护较简单的异步操作低通用一般一般
2Future/Promise使用future对象获取异步操作的结果，promise对象设置结果直观，支持等待异步操作完成对于复杂的控制流较难处理单个异步操作的结果中通用较好一般
3协程（Coroutines）使用协程来简化异步代码，避免回调地狱简化异步代码，易于编写和理解需要特定的编译器支持，不是标准的C++特性处理复杂的异步流程高部分平台支持较好较好
4异步/await（C++20）使用co_await关键字来等待异步操作的完成简化异步代码，易于编写和理解C++20新特性，不是所有平台和编译器都支持新项目或有C++20支持的项目中部分平台支持较好较好
5线程池（Thread Pool）使用线程池管理异步任务的执行，提高并发性能有效利用系统资源，降低线程创建和销毁开销需要合理调整线程池大小，可能出现任务处理不均衡高并发环境中通用一般较好
6Actor 模型使用独立的“actor”对象处理消息和并发操作易于实现并发和消息传递，避免共享数据的竞争可能引入复杂性，需要谨慎处理消息顺序分布式和并发密集型应用程序高通用一般一般
7Reactive Extensions使用可观察序列来处理异步事件和数据流强大的组合和转换操作，支持响应式编程范式学习曲线较陡，理解响应式编程概念较难响应式和事件驱动的应用程序高部分平台支持较好较好
8数据流处理框架使用数据流处理框架（如RxCpp、Boost.Asio）来处理异步流数据提供丰富的数据处理操作符和工具学习成本较高，需要熟悉框架的特性复杂的数据流处理需求高部分平台支持较好较好

4.各个示例程序

对每种异步编程模式的简要示例代码说明：

1. 回调函数（Callbacks）示例代码：

#include <iostream>
#include <functional>

void async_operation(std::function<void(int)> callback) {
    // 模拟异步操作
    int result = 42;
    callback(result);
}

int main() {
    async_operation([](int result) {
        std::cout << "异步操作完成，结果为: " << result << std::endl;
    });

    return 0;
}

输出结果

异步操作完成，结果为: 42

2. Future/Promise 示例代码：

在这里插入图片描述

#include <iostream>
#include <future>

int async_operation() {
    // 模拟异步操作
    return 42;
}

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

    int result = future_result.get();
    std::cout << "异步操作完成，结果为: " << result << std::endl;

    return 0;
}

输出结果

异步操作完成，结果为: 42

3. 协程（Coroutines）示例代码：

#include <iostream>
#include <coroutine>

struct Task {
    struct promise_type {
        Task get_return_object() {
            return Task{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void return_value(int value) { result = value; }
        void unhandled_exception() {}
        
        int result;
    };

    std::coroutine_handle<promise_type> coro;

    Task(std::coroutine_handle<promise_type> h): coro(h) {}
    ~Task() { if (coro) coro.destroy(); }
};

Task async_operation() {
    co_return 42;
}

int main() {
    Task task = async_operation();
    std::cout << "异步操作完成，结果为: " << task.coro.promise().result << std::endl;

    return 0;
}

输出结果

异步操作完成，结果为: 42

4. 异步/await（C++20）示例代码：

#include <iostream>
#include <future>

std::future<int> async_operation() {
    // 模拟异步操作
    return std::async(std::launch::async, []() {
        return 42;
    });
}

int main() {
    auto future_result = async_operation();
    int result = future_result.get();
    std::cout << "异步操作完成，结果为: " << result << std::endl;

    return 0;
}

输出结果

异步操作完成，结果为: 42

5. 线程池（Thread Pool）示例代码：

在这里插入图片描述

#include <iostream>
#include <thread>
#include <vector>
#include <queue>
#include <mutex>
#include <condition_variable>

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            threads.emplace_back([this] {
                while (true) {
                    std::function<void()> task;
                    {
                        std::unique_lock<std::mutex> lock(queue_mutex);
                        condition.wait(lock, [this] { return stop || !tasks.empty(); });
                        if (stop && tasks.empty()) {
                            return;
                        }
                        task = std::move(tasks.front());
                        tasks.pop();
                    }
                    task();
                }
            });
        }
    }

    template<class F>
    void enqueue(F&& f) {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            tasks.emplace(std::forward<F>(f));
        }
        condition.notify_one();
    }

    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(queue_mutex);
            stop = true;
        }
        condition.notify_all();
        for (std::thread& thread : threads) {
            thread.join();
        }
    }

private:
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop = false;
};

int main() {
    ThreadPool pool(4);

    for (int i = 0; i < 8; ++i) {
        pool.enqueue([i] {
            std::cout << "任务 " << i << " 在线程池中执行" << std::endl;
        });
    }

    return 0;
}

输出结果

任务 0 在线程池中执行
任务 1 在线程池中执行
任务 2 在线程池中执行
任务 3 在线程池中执行
任务 4 在线程池中执行
任务 5 在线程池中执行
任务 6 在线程池中执行
任务 7 在线程池中执行

6. Actor 示例代码：

#include <iostream>
#include <thread>
#include <queue>
#include <mutex>

class Actor {
public:
    void sendMessage(int message) {
        std::lock_guard<std::mutex> lock(mutex);
        messages.push(message);
    }

    void processMessages() {
        while (!messages.empty()) {
            int message = messages.front();
            messages.pop();
            std::cout << "接收到消息: " << message << std::endl;
        }
    }

private:
    std::queue<int> messages;
    std::mutex mutex;
};

int main() {
    Actor actor;

    std::thread producer([&actor] {
        for (int i = 0; i < 5; ++i) {
            actor.sendMessage(i);
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    });

    std::thread consumer([&actor] {
        std::this_thread::sleep_for(std::chrono::milliseconds(500));
        actor.processMessages();
    });

    producer.join();
    consumer.join();

    return 0;
}

输出结果

接收到消息: 0
接收到消息: 1
接收到消息: 2
接收到消息: 3
接收到消息: 4

7. Reactive Extensions 示例代码：

#include <iostream>
#include <vector>
#include <chrono>
#include <thread>
#include "rx.hpp"

using namespace rxcpp;
using namespace rxcpp::sources;
using namespace rxcpp::operators;
using namespace rxcpp::util;

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    auto observable = from(nums) // 创建可观察序列
        .filter([](int n) { return n % 2 == 0; }) // 过滤偶数
        .map([](int n) { return n * n; }) // 将每个数平方
        .subscribe_on(rx::serialize_new_thread()) // 在新线程上执行上述操作
        .observe_on(rx::observe_on_event_loop()); // 切回主线程

    observable.subscribe([](int n) { std::cout << n << " "; }); // 订阅序列并输出

    std::this_thread::sleep_for(std::chrono::seconds(1)); // 等待异步操作完成

    std::cout << std::endl;

    return 0;
}

使用 subscribe_on() 操作符将序列的创建、过滤和映射操作切换到一个新的线程上执行。然后，使用 observe_on() 操作符将结果切换回主线程，并在主线程上订阅序列，并输出结果

4 16 36 64 100

8. 数据流处理框架 示例代码：

#include <iostream>
#include "rx.hpp"

using namespace rxcpp;
using namespace rxcpp::sources;
using namespace rxcpp::operators;
using namespace rxcpp::util;

int main() {
    // 创建一个整数序列
    auto values = rxcpp::observable<>::range(1, 10);

    // 对序列进行转换和过滤操作
    auto result = values
        .filter([](int n) { return n % 2 == 0; }) // 过滤偶数
        .map([](int n) { return n * n; }); // 平方

    // 订阅结果并输出
    result.subscribe(
        [](int v) { std::cout << v << " "; },
        []() { std::cout << "onCompleted" << std::endl; }
    );

    return 0;
}

使用 rxcpp::observable<>::range() 创建一个整数序列，从1到10。然后，我们使用 filter() 操作符过滤掉所有奇数，再使用 map() 操作符将剩余的偶数平方。最后，我们订阅了这个序列，并在每个值被发出时输出它的值。

这段代码演示了如何使用rxcpp来处理数据流，包括创建可观察序列、对序列进行转换和过滤操作，以及订阅结果并处理每个值。通过这种方式，我们能够以可组合的方式处理数据流，实现更加灵活和高效的数据处理逻辑。

输出结果

4 16 36 64 100 onCompleted

5. 参考文档

dotnet研习社
关注
专栏目录
C++11异步编程(std::async, std::future, std::packaged_task, std::promise)
Charles_Zaqdt的博客
02-08 852
std::async是一个函数模板，会启动一个异步任务，最终返回一个std::future对象。在之前我们都是通过thread去创建一个子线程，但是如果我们要得到这个子线程所返回的结果，那么可能就需要用全局变量或者引用的方法来得到结果，这样或多或少都会不太方便，那么async这个函数就可以将得到的结果保存在future中，然后通过future来获取想要得到的结果。async比起...
C++高级编程（76）异步编程模型与Proactor模式
m0_51768024的博客
04-24 448
通过本篇博客的学习，我们应该能够理解异步编程模型以及Proactor模式的重要性，并掌握了如何在C++项目中使用这些技术进行高级应用开发。异步编程模型提供了一种强大的机制来处理并发操作，而Proactor模式则提供了一种高效的方式来管理系统资源。在实践中，我们需要根据具体的需求和场景来选择最合适的技术和工具。随着技术的发展，我们期待有更多先进的工具和方法论来帮助我们更好地利用异步编程和Proactor模式。如果您有任何疑问或想要进一步讨论，请随时在评论区留言。
c++并发编程(异步）
qq_63627616的博客
08-14 869
我们定义两个函数，分别为mythread，和mythread2：先看mythread就行，第一个参数是primise用来储存返回值，第二个参数是整型值再看主函数，启动了mythread，注意第二个参数promise对象不允许复制，必须是指针或者引用（），而且我们也希望把结果储存到这个对象本身而不是复制的副本中。然后我们通过get_future获得返回值，要注意的future对象也不能被复制，而且也不能用引用传值（future），一般通过move（移动语义）来传递。
C/C++编程：异步编程入门
OceanStar的博客
02-03 4688
背景 在产品端开发软件多了，免不了遇到多线程处理的情况，这也符合多核、异构的现代化硬件发展的需求。多线程处理中常见的有两种应用情形： 并行化算法处理。利用OpenMP/TBB等CPU并行库，或者CUDA/OpenCL等GPU并行库，将问题拆分成多个相互独立的子问题，通过并行库提供的原语来进行组织，调度多个子线程并行处理，再利用库提供的规约等操作，收集处理各个线程反馈的结果，形成最终的结果。在这类应用中，线程之间的数据交换是低频行为，尤其在算法设计阶段会刻意的避免线程之间的信息传递已达到高效处理的效果。本文
探索Idle：C++的异步动态组件框架
最新发布
gitblog_00044的博客
09-05 561
探索Idle：C++的异步动态组件框架 idleIdle is an asynchronous and hot-reloadable C++ dynamic component framework项目地址:https://gitcode.com/gh_mirrors/id/idle 在C++开发领域，寻找一个能够提升开发效率、支持热重载并且高度反应性的框架一直是开发者们的追求。今天，我们将深入介...
C++异步编程
ajffaj的博客
01-28 1356
类代表一个单独的执行线程。在创建与线程对象相关联时，线程会立即开始执行（在等待操作系统调度的延迟之后），从构造函数参数中提供的顶层函数开始执行。顶层函数的返回值被忽略，如果它通过抛出异常终止，则会调用。对象也可以处于不表示任何线程的状态（默认构造、移动、分离或加入之后），而且执行线程可能不与任何对象关联（分离之后）。不可复制构造或复制赋值，但是可以移动构造和移动赋值。otherother销毁线程对象。
C++实现异步编程
beibeix2015的博客
04-19 2712
参考 C++多线程并发（四）---异步编程
C++ 异步编程
qq_37174816的博客
05-29 1948
std::package_task类似于std::functional，需要显示的调用，特殊的是，它自动会把返回值可以传递给std::future。的时候才会创建线程)，这两个参数是std::async的第一个参数，如果没有使用这个两个参数，也就是第一个参数为空的话，那么第一个参数默认为std::launch::async 或者 std::launch::deferred，这个就不可控了，由操作系统根据当时的运行环境来确定是当前创建线程还是延迟创建线程。std::promise是一个类模板，它的作用是。
彻底了解C++异步从理论到实践
Linuxhus的博客
07-16 569
来源于1.6Xboost同期的asiostandalone版本去除了各平台网络处理相关的代码仅保留了post和相关的功能(新版本有executor实现)早期c++11兼容,无coroutine支持除网络库外,asio非常有使用价值的一部分代码。
Qt 5.9 C++开发指南-Qt核心特点源码
09-16
总结，Qt 5.9提供了强大的工具和框架，以支持高效、跨平台的C++开发。深入理解其核心特点和源码，将使你能够更好地利用Qt进行软件开发，创建出高效、美观的应用程序。通过实践与学习，你将成为一名精通Qt 5.9的...
用C++ concurrencytask实现异步编程（附代码实例）.rar
03-04
用C++ concurrencytask实现异步编程（附代码实例）.rar
Boost.Asio C++ 网络编程.pdf
10-11
这包括同步和异步版本的客户端和服务端，帮助读者理解不同编程模式的实际应用。 **异步编程**是Asio的一个核心特性，书中深入探讨了异步I/O的运行机制，如`async_read`、`async_write`和`async_connect`等函数，...
王健伟老师_Linux C++网络编程_工程思维导图.pdf
10-23
在对王健伟老师的Linux C++网络编程课程进行辅助学习时，工程思维导图作为一种图形化思维工具，可以帮助学生更系统地理解和掌握复杂的知识点。这份资料中提到的内容涉及到网络编程的多个关键概念和实现细节，下面将...
「C++」掌握C++异步编程
CaTianRi的博客
04-18 1072
异步任务是多线程编程的核心，若想学习多线程设计，深入了解这些基本概念是必不可少的。如果你从未了解过这些概念，亦或者对c++异步任务的库函数有所遗忘了，不妨点进本文来学习一下。
C++的简单异步
个人进步之路
03-15 655
位置 主要有:懒/执行器/生成器/批操作/协程锁/协程条件变量/有栈协程等组件. 简单回声示例 简单异步::协程::懒<空> 会话(传控::套接字 套接字){ 对(;;){ 常 大小型 最大长度=1024; 符 数据[最大长度]; 动[错误,长度]=协待 异步读些(套接字,异网::缓冲(数据,最大长度)); 如(错误){ 抛 异网::系统错误(错误); } 协待 异步写
c++ 异步编程
daniaokuye的专栏
10-10 3070
背景 需要提高工程运行效率，将里面多个环节进行同步处理。但是在网上找了几个demo之后，发现调用复杂的库（future等）和模块用到的库可能存在潜在的冲突，结果future好像和tensorRT冲突，thread好像和openGL冲突。存在一些问题。试来试去，还是最简单的thread比较好使，openGL的问题留给以后解决吧。 代码 //g++ -o mu test.cpp -std=c++11 ...
【C++】基础：异步操作模型与示例
DevFrank的博客
12-25 1601
异步操作模型与示例
C++11异步编程
冯同学的博客
03-11 1228
C++11中的异步编程，包括std::future，std::promise，std::packaged_task和std::async
C语言中接口异步执行，不阻塞
05-23
在C语言中，要实现异步执行且不阻塞的接口，可以使用多线程或异步回调函数。 1. 使用多线程 可以使用pthread库中的pthread_create函数创建一个新线程，将需要异步执行的任务放在新线程中执行，主线程可以继续执行其他任务，不会被阻塞。 示例代码： ```c #include <stdio.h> #include <pthread.h> void* async_task(void* arg) { // 异步执行的任务 printf("Async task is running.\n"); return NULL; } int main() { pthread_t thread; int ret = pthread_create(&thread, NULL, async_task, NULL); if (ret != 0) { printf("Failed to create thread.\n"); return 1; } printf("Main thread is running.\n"); // 等待异步任务完成 pthread_join(thread, NULL); return 0; } ``` 2. 使用异步回调函数 可以使用异步回调函数来实现异步执行，不阻塞。具体实现方式是，在调用接口时，传入一个回调函数，异步任务完成后，调用回调函数通知结果。 示例代码： ```c #include <stdio.h> #include <stdlib.h> #include <unistd.h> typedef void (*async_callback)(int result); void async_task(async_callback callback) { // 异步执行的任务 sleep(3); int result = rand() % 100; callback(result); } void async_callback_func(int result) { printf("Async task is finished, result = %d.\n", result); } int main() { async_task(async_callback_func); printf("Main thread is running.\n"); return 0; } ``` 在上面的代码中，async_task函数是一个异步执行的任务，它接收一个回调函数作为参数，任务完成后调用回调函数通知结果。在主函数中，调用async_task函数时传入了一个回调函数async_callback_func。这样，在异步任务完成后，会调用async_callback_func函数通知结果。在此期间，主线程可以继续执行其他任务，不会被阻塞。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

dotnet研习社

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值