concurrencpp：C++并发编程的利器-CSDN博客

本文链接：https://blog.csdn.net/gitblog_00034/article/details/139110436

concurrencpp：C++并发编程的利器

concurrencpp Modern concurrency for C++. Tasks, executors, timers and C++20 coroutines to rule them all 项目地址: https://gitcode.com/gh_mirrors/co/concurrencpp

Latest Release

项目介绍

concurrencpp 是一个强大的C++并发库，旨在将并发任务引入C++世界。通过使用任务、执行器和协程，开发者可以轻松编写高度并发的应用程序，同时确保代码的安全性和易用性。concurrencpp 允许开发者将大型异步处理过程分解为更小的并发任务，这些任务以协作的方式运行，共同实现所需的结果。此外，concurrencpp 还支持并行算法，使编写并行代码变得更加简单。

项目技术分析

concurrencpp 的核心优势在于其高层次的并发抽象，避免了直接使用低层次的并发原语（如 std::thread 和 std::mutex）。通过使用C++20协程和 co_await 关键字，开发者可以轻松实现非阻塞的同步代码。此外，concurrencpp 提供了多种常用的执行器，并支持自定义执行器的扩展。这些特性使得 concurrencpp 在处理高并发和并行任务时表现出色，同时减少了数据竞争、死锁等并发问题的可能性。

项目及技术应用场景

concurrencpp 适用于需要高度并发和并行处理的应用场景，例如：

高性能计算：在科学计算、数据分析等领域，concurrencpp 可以帮助开发者充分利用多核处理器的性能。
网络服务：在服务器端应用中，concurrencpp 可以处理大量的并发请求，提高系统的吞吐量。
实时系统：在需要快速响应的实时系统中，concurrencpp 可以确保任务的及时执行和结果的快速返回。

项目特点

高层次抽象：使用任务代替线程，简化了并发编程的复杂性。
自动扩展：根据硬件资源自动调整并发度，充分利用系统资源。
协程支持：通过C++20协程实现非阻塞的同步代码，提高代码的可读性和可维护性。
内置同步：通过高层次的对象内置同步机制，减少并发问题的发生。
可扩展性：支持自定义执行器，满足不同应用场景的需求。
成熟稳定：经过多个平台和操作系统的测试，确保稳定性和可靠性。

示例代码

"Hello World" 程序

#include "concurrencpp/concurrencpp.h"
#include <iostream>

int main() {
    concurrencpp::runtime runtime;
    auto result = runtime.thread_executor()->submit([] {
        std::cout << "hello world" << std::endl;
    });

    result.get();
    return 0;
}

并发计数示例

#include "concurrencpp/concurrencpp.h"

#include <iostream>
#include <vector>
#include <algorithm>

#include <ctime>

using namespace concurrencpp;

std::vector<int> make_random_vector() {
    std::vector<int> vec(64 * 1'024);

    std::srand(std::time(nullptr));
    for (auto& i : vec) {
        i = ::rand();
    }

    return vec;
}

result<size_t> count_even(std::shared_ptr<thread_pool_executor> tpe, const std::vector<int>& vector) {
    const auto vecor_size = vector.size();
    const auto concurrency_level = tpe->max_concurrency_level();
    const auto chunk_size = vecor_size / concurrency_level;

    std::vector<result<size_t>> chunk_count;

    for (auto i = 0; i < concurrency_level; i++) {
        const auto chunk_begin = i * chunk_size;
        const auto chunk_end = chunk_begin + chunk_size;
        auto result = tpe->submit([&vector, chunk_begin, chunk_end]() -> size_t {
            return std::count_if(vector.begin() + chunk_begin, vector.begin() + chunk_end, [](auto i) {
                return i % 2 == 0;
            });
        });

        chunk_count.emplace_back(std::move(result));
    }

    size_t total_count = 0;

    for (auto& result : chunk_count) {
        total_count += co_await result;
    }

    co_return total_count;
}

int main() {
    concurrencpp::runtime runtime;
    const auto vector = make_random_vector();
    auto result = count_even(runtime.thread_pool_executor(), vector);
    const auto total_count = result.get();
    std::cout << "there are " << total_count << " even numbers in the vector" << std::endl;
    return 0;
}