为何线程池嵌套任务等待会导致应用无限阻塞？

首先，你的程序无法结束的核心原因是线程池构造时的lambda捕获错误：

在ThreadPool的构造函数中，你给worker线程的lambda用了值捕获[=]，这意味着捕获的stop是成员变量stop的一个副本（初始值为false）。当ThreadPool的析构函数将成员变量stop设为true时，worker线程里的等待条件判断用的是捕获的副本，永远看不到stop的更新，会一直阻塞在condition.wait上，永远不会退出循环，自然导致程序无法结束。

除此之外，你的实现还有两个关键问题需要修复：

其他潜在问题 #

1. 任务队列的类型不兼容 #

你定义的Task是std::packaged_task<void()>，但Enqueue函数接受的任务可能返回非void类型（比如一个返回int的lambda）。此时std::packaged_task<decltype(task())()>无法隐式转换为std::packaged_task<void()>，会直接导致编译错误。即使当前示例中的任务都是返回void，这个设计也不通用，扩展性很差。

2. 数据竞争导致未定义行为 #

在DoSomethingStruct::DoSomething中，多个线程同时调用ints.push_back(i)，但std::vector不是线程安全的容器，这种无保护的并发修改会引发未定义行为——可能是数据损坏、程序崩溃，甚至间接影响程序的退出逻辑。

修复后的完整实现 #

修正后的ThreadPool #

#include <vector>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <future>
#include <functional>
#include <memory>

struct ThreadPool { 
    // 改用std::function<void()>存储任务，适配任意返回类型的可调用对象
    using Task = std::function<void()>; 

    explicit ThreadPool(size_t workersCount) { 
        workers.reserve(workersCount); 
        for(uint32_t i = 0u; i < workersCount; ++i) { 
            // 使用[this]引用捕获，确保访问最新的成员变量
            workers.emplace_back([this]() { 
                while(true) { 
                    Task task; 
                    { 
                        std::unique_lock<std::mutex> locker(mutex); 
                        // 谓词直接访问成员变量stop，而非副本
                        condition.wait(locker, [this]() { return stop || !tasks.empty(); }); 
                        if(stop && tasks.empty()) { 
                            break; 
                        } 
                        task = std::move(tasks.front()); 
                        tasks.pop(); 
                    } 
                    task(); 
                } 
            }); 
        } 
    } 

    ~ThreadPool() noexcept { 
        {
            std::unique_lock<std::mutex> locker(mutex);
            stop = true;
        }
        condition.notify_all(); 
        for(auto& worker : workers) { 
            if(worker.joinable()) {
                worker.join(); 
            }
        } 
        workers.clear(); 
    } 

    template<typename T> 
    auto Enqueue(T task)->std::future<decltype(task())> { 
        using ReturnType = decltype(task());
        // 用shared_ptr持有packaged_task，避免拷贝（packaged_task不可拷贝）
        auto package = std::make_shared<std::packaged_task<ReturnType()>>(std::move(task));
        auto result = package->get_future(); 
        { 
            std::unique_lock<std::mutex> locker(mutex); 
            // 将packaged_task包装为std::function<void()>放入队列
            tasks.emplace([package]() {
                (*package)();
            }); 
        } 
        condition.notify_one(); 
        return result; 
    } 

    std::vector<std::thread> workers; 
    std::queue<Task> tasks; 
    std::mutex mutex; 
    std::condition_variable condition; 
    std::atomic_bool stop = false; 
};

修正后的示例代码（解决数据竞争） #

#include <mutex>

static ThreadPool pool{4}; 

struct DoSomethingStruct { 
    void DoSomething() { 
        std::vector<std::future<void>> futures; 
        for(uint32_t i = 0; i < 10; ++i) { 
            futures.push_back(pool.Enqueue([this, i]() { 
                std::lock_guard<std::mutex> lock(mtx);
                ints.push_back(i); 
            })); 
        } 
        for(const auto& future : futures) { 
            future.wait(); 
        } 
    } 
    std::vector<int> ints; 
    std::mutex mtx; // 新增互斥锁保护vector的线程安全访问
}; 

int main() { 
    DoSomethingStruct dss; 
    std::vector<std::future<void>> futures; 
    for(uint32_t i = 0; i < 10; ++i) { 
        futures.push_back(pool.Enqueue([&dss, i]() { dss.DoSomething(); })); 
    } 
    for(const auto& future : futures) { 
        future.wait(); 
    } 
    return 0; 
}

关键修正点说明 #

1. 引用捕获this：worker线程的lambda通过[this]捕获ThreadPool的指针，直接访问成员变量，确保能获取到stop的最新值，解决了析构时无法唤醒worker的核心问题。
2. 任务队列改用std::function<void()>：通过std::shared_ptr持有packaged_task，将任意返回类型的任务包装为std::function<void()>，既解决了类型不兼容问题，又保留了返回值的传递能力（通过std::future）。
3. 线程安全的容器访问：给std::vector<int>添加互斥锁，避免多线程并发修改导致的未定义行为。

内容的提问来源于stack exchange，提问作者BrodaJarek3