高级线程管理：线程池

#include <condition_variable>
#include <functional>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>
 
class ThreadPool {
    std::vector<std::thread> workers;        // 固定一队工作线程
    std::queue<std::function<void()>> tasks; // 任务队列
    std::mutex m;
    std::condition_variable cv;
    bool done = false;                       // 析构信号
    void worker_loop() {
        while (true) {
            std::function<void()> task;
            {
                std::unique_lock<std::mutex> lk(m);
                cv.wait(lk, [this] { return done || !tasks.empty(); });
                if (done && tasks.empty()) return; // 收工且无活就退
                task = std::move(tasks.front());
                tasks.pop();
            }
            task();                          // 在锁外执行，别占着锁干活
        }
    }
};

#include <condition_variable>
#include <functional>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>
 
class ThreadPool {
    std::vector<std::thread> workers;
    std::queue<std::function<void()>> tasks;
    std::mutex m;
    std::condition_variable cv;
    bool done = false;
    void worker_loop();                      // 实现见上一段
public:
    explicit ThreadPool(unsigned n = std::thread::hardware_concurrency()) {
        if (n == 0) n = 1; // 只是默认提示；生产配置应由负载测量给出
        try {
            for (unsigned i = 0; i < n; ++i)
                workers.emplace_back([this] { worker_loop(); });
        } catch (...) {
            { std::lock_guard<std::mutex> lk(m); done = true; }
            cv.notify_all();
            for (auto& t : workers) t.join();
            throw;
        }
    }
    ~ThreadPool() {
        { std::lock_guard<std::mutex> lk(m); done = true; } // 置收工信号
        cv.notify_all();                     // 叫醒所有在等任务的工人
        for (auto& t : workers) t.join();    // 等每个工人收工，绝不漏 join
    }
};

#include <condition_variable>
#include <functional>
#include <future>
#include <memory>
#include <mutex>
#include <queue>
#include <stdexcept>
#include <type_traits>
#include <utility>
 
class ThreadPool {
    std::queue<std::function<void()>> tasks;
    std::mutex m;
    std::condition_variable cv;
    bool done = false;
public:
    // 提交任务，返回一张 future 凭证去取它的结果
    template <typename F>
    auto submit(F&& f)
        -> std::future<std::invoke_result_t<std::decay_t<F>&>> {
        using Fn = std::decay_t<F>;
        using R = std::invoke_result_t<Fn&>;
        auto task = std::make_shared<std::packaged_task<R()>>(
            std::forward<F>(f));
        std::future<R> fut = task->get_future();
        {
            std::lock_guard<std::mutex> lk(m);
            if (done) throw std::runtime_error("thread pool is stopping");
            tasks.push([task] { (*task)(); }); // 入队（用 shared_ptr 搬进 function）
        }
        cv.notify_one();                       // 叫醒一个等任务的工人
        return fut;                            // 调用方凭它 get() 取结果/异常
    }
};

#include <future>
#include <functional>
#include <queue>
#include <utility>
 
// 假设已有上面那个带 submit 的 ThreadPool；这里给个等价的最小桩聚焦用法
struct ThreadPool {
    explicit ThreadPool(unsigned) {}
    template <typename F>
    auto submit(F f) -> std::future<decltype(f())> {
        std::packaged_task<decltype(f())()> task(std::move(f));
        auto fut = task.get_future();
        task();                 // 真线程池里是入队、由某个工人取出执行
        return fut;
    }
};
 
int use_pool() {
    ThreadPool pool(4);                       // 固定 4 个工人
    std::future<int> f = pool.submit([] {     // 派一个返回 int 的任务
        int s = 0;
        for (int i = 1; i <= 100; ++i) s += i;
        return s;                             // 返回值会被填进 f
    });
    return f.get();                           // 取餐：没算完就阻塞，直到就绪（5050）
}

#include <deque>
#include <functional>
#include <mutex>
#include <optional>
#include <utility>
 
using Task = std::function<void()>;
 
// 每个工作线程一条本地双端队列：本端 push/pop（无争用），队尾给别人偷
class WorkStealingQueue {
    std::deque<Task> q;
    mutable std::mutex m;
public:
    void push(Task t) { // 本线程提交：压本端（front）
        std::lock_guard<std::mutex> lk(m);
        q.push_front(std::move(t));
    }
    std::optional<Task> try_pop() { // 本线程取活：本端拿（LIFO）
        std::lock_guard<std::mutex> lk(m);
        if (q.empty()) return std::nullopt;
        Task t = std::move(q.front()); q.pop_front();
        return t;
    }
    std::optional<Task> try_steal() { // 别人来偷：队尾拿（减冲突）
        std::lock_guard<std::mutex> lk(m);
        if (q.empty()) return std::nullopt;
        Task t = std::move(q.back()); q.pop_back();
        return t;
    }
};

#include <functional>
#include <optional>
#include <thread>
#include <vector>
 
using Task = std::function<void()>;
 
struct WorkStealingQueue {
    std::optional<Task> try_pop();
    std::optional<Task> try_steal();
};
 
std::vector<WorkStealingQueue*> all_queues; // 所有工人的本地队列
thread_local WorkStealingQueue* my_queue;   // 本线程自己的那条
 
// 工人每轮：先吃自己的，空了再去别人队尾偷
void run_pending_task() {
    if (auto t = my_queue->try_pop()) {     // ① 先取自己本端的活
        (*t)();
        return;
    }
    for (auto* other : all_queues) {         // ② 自己空了，遍历同事
        if (other == my_queue) continue;
        if (auto t = other->try_steal()) {   // 从同事队尾偷一张
            (*t)();
            return;
        }
    }
    std::this_thread::yield(); // 完整池应阻塞等待新任务，避免持续轮询
}

#include <atomic>
#include <stdexcept>
 
// 中断信号：一个原子布尔标志（每个可中断线程各有一个）
class interrupt_flag {
    std::atomic<bool> flag{false};
public:
    void set() { flag.store(true, std::memory_order_relaxed); } // interrupt() 调它置位
    bool is_set() const { return flag.load(std::memory_order_relaxed); }
};
 
// 抛出它表示「收到中断、正在退出」——可被 catch 做清理
struct thread_interrupted : std::runtime_error {
    thread_interrupted() : std::runtime_error("interrupted") {}
};
 
// 每个可中断线程一个；指向自己那面 flag
thread_local interrupt_flag* this_thread_interrupt_flag = nullptr;
 
// 中断点：线程主动「抬头看一眼信号」，置位了就抛出退出
void interruption_point() {
    if (this_thread_interrupt_flag && this_thread_interrupt_flag->is_set())
        throw thread_interrupted();
}

#include <atomic>
 
class interrupt_flag {
    std::atomic<bool> flag{false};
public:
    void set() { flag.store(true, std::memory_order_relaxed); }
    bool is_set() const { return flag.load(std::memory_order_relaxed); }
};
thread_local interrupt_flag* this_thread_interrupt_flag = nullptr;
struct thread_interrupted {};
void interruption_point() {
    if (this_thread_interrupt_flag && this_thread_interrupt_flag->is_set())
        throw thread_interrupted();
}
 
bool has_more_work();
void do_one_chunk();
void cleanup();
 
// 业务循环：每干完一块就到「中断点」自查一次——这是协作式的关键
void worker_body() {
    try {
        while (has_more_work()) {
            do_one_chunk();        // 干一个段落的活
            interruption_point();  // 抬头看信号：置位了就在这里抛出退出
        }
    } catch (thread_interrupted const&) {
        cleanup();                 // 收到中断：干净收尾（释放资源等）
    }
}