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

我正试图从

C++11

学习

std:：threads

来制作一个线程系统

我想知道是否有一种方法可以在不终止整个程序的情况下停止线程的运行（不是休眠，而是真正破坏线程或者可以这么说）

我知道存在

std:：join

，但这会迫使线程等待所有线程返回

---

还有别的办法吗？（例如，创建

线程池

类而不必阻止线程？

此线程池可能会帮助您：

#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();
      }
};

#包括
#包括
#包括
使用名称空间boost；
使用名称空间boost:：phoenix:：arg_名称；
boost：：原子大小计数器（0ul）；
类线程池
{
私人：
互斥mx；
条件变量cv；
类型定义功能作业；
std:：deque_队列；
线程组池；
原子弹爆炸关机；
静态无效工作线程（线程池和q）
{
while（可选作业=q.dequeue（））
（*工作）（）；
}
公众：
线程池（）：关闭（false）{
for（无符号i=0；i

---

使用示例：<强>

> P>无法用标准C++来阻止线程停止运行。这并不意味着这是不可能的，但您可能需要回到您的系统本机句柄

---

对于符合标准的方式，您可以使用同步原语（例如，

std:：atomic

）从外部设置kill标志，并在线程内读取。但它仍然必须是线程自己完成的。

< P> C++ >代码> STD:：线程类实际上只是一个最小的接口，它是在一些更完整的实现定义的线程包之上的。因此，它只定义了少量功能——创建新线程、

detach

和

join

。基本上就是这样——没有标准的方法来管理、调度、停止/启动/终止线程或做很多其他事情

---

有一个

native\u handle

方法返回一个实现定义的类型，根据实现的不同，该类型可能用于执行您想要的操作。

没有这种现成的可能性。但是您可以尝试boost:：thread或编写自己的此功能的实现

std:：thread

几乎知道线程实现必须知道的一切：1）创建线程2）加入它。你不需要其他任何东西。不幸的是，优雅地“杀死线程”实际上是要求线程退出，并在退出时加入它。有时，实现这一点取决于平台，但对于事件/条件，您通常可以在平台上独立实现。很好地使用

而
（
声明
）
我真的不明白这一点。std:：thread拥有底层线程实现的所有功能（模块化那些不能移植使用或使用起来不安全的东西。各个“线程包”中的所有其他重要位也都在那里（条件变量（a.k.a.event），（递归）互斥（a.k.a.critical section），（唯一）锁、助手等。