Question

我正在尝试从std::threads了解C++11以制作线程系统。

我想知道是否有办法阻止一个线程运行（没有睡觉，但真的破坏了线程或者这么说）而没有终止整个程序。

我知道std::join存在，但这迫使线程等待所有线程返回。

还有另一种方法可以解决这个问题吗？（例如，在不必阻塞线程的情况下创建ThreadPool类？）

Answer 1

也许这个thread_pool会帮助你：

#include <boost/thread.hpp>
#include <boost/phoenix.hpp>
#include <boost/optional.hpp>

using namespace boost;
using namespace boost::phoenix::arg_names;

boost::atomic_size_t counter(0ul);

class thread_pool
{
  private:
      mutex mx;
      condition_variable cv;

      typedef function<void()> job_t;
      std::deque<job_t> _queue;

      thread_group pool;

      boost::atomic_bool shutdown;
      static void worker_thread(thread_pool& q)
      {
          while (optional<job_t> job = q.dequeue())
              (*job)();
      }

  public:
      thread_pool() : shutdown(false) {
          for (unsigned i = 0; i < boost::thread::hardware_concurrency(); ++i)
              pool.create_thread(bind(worker_thread, ref(*this)));
      }

      void enqueue(job_t job) 
      {
          lock_guard<mutex> lk(mx);
          _queue.push_back(job);

          cv.notify_one();
      }

      optional<job_t> dequeue() 
      {
          unique_lock<mutex> lk(mx);
          namespace phx = boost::phoenix;

          cv.wait(lk, phx::ref(shutdown) || !phx::empty(phx::ref(_queue)));

          if (_queue.empty())
              return none;

          job_t job = _queue.front();
          _queue.pop_front();

          return job;
      }

      ~thread_pool()
      {
          shutdown = true;
          {
              lock_guard<mutex> lk(mx);
              cv.notify_all();
          }

          pool.join_all();
      }
};

使用示例： live On Coliru

Answer 2

没有办法非合作地阻止线程运行标准C ++。这并不意味着它是不可能的，但您可能需要回到系统本机句柄。

对于标准符合方式，您可以使用同步原语（例如std::atomic<bool>）从外部设置kill标志并在线程内读取它。但它仍然必须是自己完成的线程。

Answer 3

C ++ std::thread类实际上只是在一些更完整的实现定义的线程包之上分层的最小接口。因此，它仅定义了少量功能 - 创建新线程detach和join。这就是它 - 没有标准的管理，调度，停止/启动/杀死线程或做其他事情的方法。

有一个native_handle方法返回一个实现定义的类型，它可能用于执行您想要的操作，具体取决于实现。

如何在不终止程序的情况下停止运行std :: thread

3 个答案: