C++并发编程之std::for_each的并行版本

在C++中，std::for_each 是一个用于顺序遍历容器的算法。为了提高性能，我们可以设计并实现一个并行版本的 std::for_each，以便在多核处理器上并行执行操作。基本思想是将容器中的元素划分为若干块，每个块由一个单独的线程处理。

基本思想

1. 任务划分：将容器中的元素划分成多个子范围（块），每个子范围由一个线程处理。任务划分的粒度可以根据容器的规模和处理器的核心数进行调整。
2. 线程执行：每个线程独立处理分配给它的子范围，执行相同的操作。
3. 等待同步：在所有线程完成其任务后，主线程等待所有线程完成，然后继续执行后续操作。

实现代码

我们可以使用 C++11 的 std::thread 和 std::mutex 来实现并行版本的 std::for_each。为了简化实现，我们可以使用 std::vector 来管理线程，并使用 std::mutex 来保护共享资源（如果需要）。

#include 
#include 
#include 
#include 
#include 

// 并行版本的 std::for_each
template
void parallel_for_each(Iterator first, Iterator last, Func f) {
    const unsigned long length = std::distance(first, last);

    // 如果没有元素，直接返回
    if (length == 0) {
        return;
    }

    // 获取系统支持的并发线程数
    const unsigned long max_threads = std::thread::hardware_concurrency();
    const unsigned long num_threads = std::min(max_threads != 0 ? max_threads : 2, length);

    // 每个线程处理的元素数量
    const unsigned long block_size = length / num_threads;

    std::vector threads(num_threads - 1);
    std::vector mutexes(num_threads);

    // 启动线程
    for (unsigned long i = 0; i < num_threads - 1; ++i) {
        Iterator block_start = first + i * block_size;
        Iterator block_end = block_start + block_size;
        threads[i] = std::thread([block_start, block_end, &f, &mutexes, i]() {
            for (Iterator it = block_start; it != block_end; ++it) {
                std::lock_guard lock(mutexes[i]);
                f(*it);
            }
        });
    }

    // 主线程处理最后一个块
    Iterator block_start = first + (num_threads - 1) * block_size;
    for (Iterator it = block_start; it != last; ++it) {
        std::lock_guard lock(mutexes[num_threads - 1]);
        f(*it);
    }

    // 等待所有线程完成
    std::for_each(threads.begin(), threads.end(), std::mem_fn(&std::thread::join));
}

// 示例函数对象
struct Printer {
    void operator()(int x) const {
        std::cout << x << " ";
    }
};

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

    // 使用并行版本的 std::for_each
    parallel_for_each(v.begin(), v.end(), Printer());

    return 0;
}

代码说明

1. 任务划分：

   • length 是容器中元素的总数。
   • max_threads 是系统支持的并发线程数，num_threads 是我们实际使用的线程数（不超过元素数量）。
   • block_size 是每个线程处理的元素数量。

2. 线程执行：

   • 我们创建了一个 std::vector 来存储所有线程。
   • 每个线程处理一个子范围 [block_start, block_end)，并调用传入的操作函数 f。
   • 主线程处理最后一个块的剩余部分。

3. 等待同步：

   • 主线程通过 std::thread::join 等待所有子线程完成。

应用

并行版本的 std::for_each 可以用于需要对大量数据进行相同操作的场景，例如：

1. 大规模数据处理：

   • 例如，处理图像的像素数据、音频数据的滤波操作、矩阵乘法等。

2. 并行计算：

   • 例如，并行计算斐波那契数列、并行排序算法等。

3. 高吞吐量的服务器应用：

   • 例如，并行处理多个客户端请求，每个请求由一个单独的线程处理。

总结

通过实现并行版本的 std::for_each，我们可以在多核处理器上并行执行操作，从而提高程序的性能。代码中展示了如何将容器中的元素划分为多个子范围，并使用多个线程分别处理这些子范围。这种技术可以广泛应用于需要高效处理大规模数据的场景。