带有作业队列的线程池卡住了

Question

我想在多个std::thread工作人员之间拆分工作，并在他们全部完成后继续。 为此，我主要基于this SO answer实现了一个线程池class。 然而，我注意到我的基准测试可能会卡住，永远运行，而不会抛出任何错误。

我写了一个最小的复制代码，附在最后。 基于终端 output，问题似乎发生在作业排队时。 我查看了视频 ( 1 、 2 )、文档 ( 3 ) 和博客文章 ( 4 )。 我尝试使用原子替换锁的类型。 我找不到根本原因。

这是复制问题的片段。 该程序重复计算测试向量中的奇数元素。

#include <atomic>
#include <condition_variable>
#include <functional>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <vector>

class Pool {
  public:
    const int worker_count;
    bool to_terminate = false;
    std::atomic<int> unfinished_tasks = 0;
    std::mutex mutex;
    std::condition_variable condition;
    std::vector<std::thread> threads;
    std::queue<std::function<void()>> jobs;

    void thread_loop()
    {
        while (true) {
            std::function<void()> job;
            {
                std::unique_lock<std::mutex> lock(mutex);
                condition.wait(lock, [&] { return (!jobs.empty()) || to_terminate; });

                if (to_terminate)
                    return;

                job = jobs.front();
                jobs.pop();
            }
            job();
            unfinished_tasks -= 1;
        }
    }

  public:
    Pool(int size) : worker_count(size)
    {
        if (size < 0)
            throw std::invalid_argument("Worker count needs to be a positive integer");

        for (int i = 0; i < worker_count; ++i)
            threads.push_back(std::thread(&Pool::thread_loop, this));
    };

    ~Pool()
    {
        {
            std::unique_lock lock(mutex);
            to_terminate = true;
        }
        condition.notify_all();
        for (auto &thread : threads)
            thread.join();
        threads.clear();
    };

    void queue_job(const std::function<void()> &job)
    {
        {
            std::unique_lock<std::mutex> lock(mutex);
            jobs.push(job);
            unfinished_tasks += 1;
            // std::cout << unfinished_tasks;
        }
        condition.notify_one();
    }

    void wait()
    {
        while (unfinished_tasks) {
            ; // spinlock
        };
    }
};

int main()
{
    constexpr int worker_count = 8;
    constexpr int vector_size = 1 << 10;
    Pool pool = Pool(worker_count);

    std::vector<int> test_vector;
    test_vector.reserve(vector_size);
    for (int i = 0; i < vector_size; ++i)
        test_vector.push_back(i);

    std::vector<int> worker_odd_counts(worker_count, 0);

    std::function<void(int)> worker_task = [&](int thread_id) {
        int chunk_size = vector_size / (worker_count) + 1;
        int my_start = thread_id * chunk_size;
        int my_end = std::min(my_start + chunk_size, vector_size);

        int local_odd_count = 0;
        for (int ii = my_start; ii < my_end; ++ii)
            if (test_vector[ii] % 2 != 0)
                ++local_odd_count;

        worker_odd_counts[thread_id] = local_odd_count;
    };

    for (int iteration = 0;; ++iteration) {
        std::cout << "Jobs.." << std::flush;
        for (int i = 0; i < worker_count; ++i)
            pool.queue_job([&worker_task, i] { worker_task(i); });
        std::cout << "..queued. " << std::flush;

        pool.wait();

        int odd_count = 0;
        for (auto elem : worker_odd_counts)
            odd_count += elem;

        std::cout << "Iter:" << iteration << ". Odd:" << odd_count << '\n';
    }
}

这是一个特定运行的终端 output：

[...]
Jobs....queued. Iter:2994. Odd:512
Jobs....queued. Iter:2995. Odd:512
Jobs..

编辑：使用 GCC 12.2.0 x86_64-w64-mingw32 在 Windows 10 上使用 AMD Ryzen 4750U CPU 时发生错误。 我没有超过 15k 次迭代。 使用 Visual Studio Community 2022，我完成了 150 万次迭代（并自行停止）。 感谢@IgorTandetnik 指出后者。

Answer 1

Mingw 本身不支持 Windows 上的多线程。他们在 POSIX API 上支持其 C++ 标准库中的线程，以及在 Windows OS 线程之上实现 API 的winpthreads兼容层。

我认为您的错误不在 C++ 代码中，而在计算机设置中。 请执行下列操作。

1. 使用x86_64-12.2.0-release-posix-seh-ucrt-rt_v10-rev2.7z存档中的编译器， 那里。

2. 不要忘记以这种方式构建的二进制文件取决于编译器提供的一堆 DLL 文件： libgcc_s_seh-1.dll 、 libwinpthread-1.dll和libstdc++-6.dll 。 您必须使用与 mingw 一起提供的这些 DLL 的完全相同的版本。 如果您的%PATH%中的任何位置都有这些 DLL 的其他版本，则可能会出现各种失败。

几个一般性的注意事项。

Linux-first C++ 编译器如 gcc 在 Windows 上有问题。阻力最小的路径是使用 Visual C++。 如果您希望您的软件也能在其他平台上构建，请考虑cmake来抽象出编译器。

Windows 已经包含一个线程池实现，从 Vista 开始。 API简单易用，只需要4个函数：CreateThreadpoolWork、SubmitThreadpoolWork、WaitForThreadpoolWorkCallbacks、CloseThreadpoolWork。 例子。

Answer 2

您应该做的第一件事是将队列从线程池中分离出来。 它们都足够棘手，将它们都写在一个 class 中是自找麻烦。

这也允许您在没有池的情况下对队列进行单元测试。

template<class Payload>
class MutexQueue {
public:
  std::optional<Payload> wait_and_pop();
  void push(Payload);
  void terminate_queue();
  bool queue_is_terminated() const;
private:
  mutable std::mutex m;
  std::condition_variable cv;
  std::deque<Payload> q;
  bool terminated = false;
  std::unique_lock<std::mutex> lock() const {
    return std::unique_lock<std::mutex>(m);
  }
};

这比线程池更容易编写。

   void push(Payload p) {
     {
       auto l = lock();
       if (terminate) return;
       q.push_back(std::move(p));
     }
     cv.notify_one();
   }
  void terminate_queue() {
     {
       auto l = lock(); // YOU CANNOT SKIP THIS LOCK, even if terminate is atomic
       terminate = true;
       q.clear();
     }
     cv.notify_all();
  }
  bool queue_is_terminated() const {
    auto l = lock(); // if you make terminate atomic, you CAN skip this lock
    return terminate;
  }
  std::optional<Payload> wait_and_pop() {
    auto l = lock();
    cv.wait(l, [&]{ return terminate || !q.empty(); }
    if (terminate) return std::nullopt;
    auto r = std::move(q.front());
    q.pop_front();
    return std::move(r);
  }

我们是 go。

现在我们的线程池更简单了。

struct ThreadPool {
  explicit ThreadPool(std::size_t n) {
    create_threads(n);
  }
  std::future<void> push_task(std::function<void()> f) {
    std::packaged_task<void()> p = std::move(f);
    auto r = p.get_future();
    q.push( std::move(p) );
    return r;
  }
  void terminate_pool() {
    q.terminate_queue();
    terminate_threads();
  }
  ~ThreadPool() {
    terminate_pool();
  }
private:
  MutexQueue<std::packaged_task<void()>> q;
  std::vector<std::thread> threads;
  void terminate_threads() {
    for(auto& thread:threads)
      thread.join();
    threads.clear();
  }
  static void thread_task( MutexQueue<std::packaged_task<void()>>* pq ) {
    if (!pq) return;
    while (auto task = pq->wait_and_pop()) {
      (*task)();
    }
  }
  void create_threads(std::size_t n) {
    for (std::size_t i = 0; i < n; ++i) {
      threads.push_back( std::thread( thread_task, &q ) );
    }
  }

我无法在您的代码中发现错误。 但是有了上面的内容，您可以测试池中队列的拆分。

该队列将与 pthreads 或其他原语一起使用。