《C++并发编程实战》第2章线程管控

最新推荐文章于 2025-12-20 15:00:56 发布

原创最新推荐文章于 2025-12-20 15:00:56 发布 · 348 阅读

CC 4.0 BY-SA版权

文章标签：


#include <iostream>
#include <thread>

class background_task
{
public:
    void operator()() const
    {
        std::cout << "operator()" << std::endl;
    }
};

int main()
{
    // std::thread t1(background_task());   // 会被当成声明
    // 解决1：
    std::thread t1((background_task())); // 使用额外的括号
    // 解决2
    std::thread t1{background_task()}; // 使用花括号初始化
    std::cout << "_______" << std::endl;
    return 0;
}

向线程函数传递参数

防止joinable没有被调用

注意有时候，线程访问一个局部变量之后，虽然主线程调用了join()函数，但是有时候子线程抛出异常。导致join不能被执行，为此我们应该防止这种情况的出现.
方法一

方法二

可调用对象的参数是引用类型

传入的可调用对象的参数是引用类型时

std::thread 根本不在乎你的函数参数是不是“引用”，它默认一律“先拷贝一份”再说。

如果参数是const引用，无所谓，因为是万能引用是都可以接受。但是只是单纯的左值引用时，使用std::ref进行包装

thread_guard和jthread

在这里插入图片描述

在运行时选择线程数量

在这里插入图片描述

为什么要用它们而不是直接用 it + n 或 it - it？因为不是所有容器（比如 std::list）都支持 + 或 - 运算符。使用 std::distance 和 std::advance 可以让你的并发算法适用于任何标准容器，增强了代码的通用性。

并发加法


template <typename Iterator, typename T>
struct accumulate_block
{
    void operator()(Iterator first, Iterator last, T &result)
    {
        result = std::accumulate(first, last, result);
    }
};
template <typename Iterator, typename T>
T parallel_accumulate(Iterator first, Iterator last, T init)
{
    unsigned const long length = std::distance(first, last);
    if (!length)
        return init;
    unsigned long const min_per_thread = 25;
    unsigned long const max_threads = (length + min_per_thread - 1) / min_per_thread;
    unsigned long const hardware_threads = std::thread::hardware_concurrency();
    unsigned long const num_threads = std::min(hardware_threads != 0 ? hardware_threads : 2, max_threads);
    unsigned long const block_size = length / num_threads;
    std::vector<T> results(num_threads);
    std::vector<std::thread> threads(num_threads - 1);
    Iterator block_start = first;
    for (unsigned long i = 0; i < (num_threads - 1); ++i)
    {
        Iterator block_end = block_start;
        std::advance(block_end, block_size);
        threads[i] = std::thread(accumulate_block<Iterator, T>(),
                                 block_start, block_end, std::ref(results[i]));
        block_start = block_end;
    }
    accumulate_block<Iterator, T>()(block_start, last, results[num_threads - 1]);
    for (auto &entry : threads)
        entry.join();
    return std::accumulate(results.begin(), results.end(), init);
}