C++ 终止正在运行的boost线程

我目前有一个这样的boost线程

class foo
{
  private:
  boost::shared_ptr<boost::thread> t;
  public:
  foo()
  {
    t = boost::make_shared<boost::thread>(&foo::SomeMethod,this);
  }
  void SomeMethod()
  {
    while(true)
    {
       .... //Does some work
    boost::this_thread::sleep(boost::posix_time::milliseconds(5000)); //sleep for 5 seconds
    }
  }

  void stopThread()
  {
    //Elegant and instant way of stopping thread t
  }
}

class-foo
{
私人：
boost：：共享\u ptr t；
公众：
foo（）
{
t=boost:：make_shared（&foo:：SomeMethod，this）；
}
void方法（）
{
while（true）
{
..//做一些工作
boost:：this_线程：：sleep（boost:：posix_时间：：毫秒（5000））；//睡眠5秒
}
}
void stopThread（）
{
//优雅而即时的停线方式
}
}

我从文章中读到，你们必须定义中断点，但我不确定我是否理解这将如何适合我的场景。我正在寻找一种安全、优雅的方法来确保线程t被终止

你永远不能安全地终止线程，你只需要从外部告诉它应该停止。如果你中断了一个线程，你不知道你在哪里中断了它，你可能会让系统处于未知状态

您可以检查线程循环中的变量（确保它是线程安全的！），以查看线程是否应该退出，而不是永远循环。我在工作线程中所做的是让它们等待一个条件变量，然后当有工作时，它们醒来并开始工作，但当它们醒来时，它们也会检查“shutdown”标志，看看是否应该退出

我的代码片段：

//-----------------------------------------------------------------------------
void Manager::ThreadMain() {
    unique_lock<mutex> lock( m_work_mutex, std::defer_lock );
    while( true ) {
        lock.lock();
        while( m_work_queue.empty() && !m_shutdown ) {
            m_work_signal.wait( lock );
        }

        if( !m_work_queue.empty() ) {

            // (process work...)
            continue;
        }

        // quit if no work left and shutdown flag set.
        if( m_shutdown ) return;
    }
}

//-----------------------------------------------------------------------------
void管理器：：ThreadMain（）{
唯一的锁（m_工作互斥锁，标准：：延迟锁）；
while（true）{
lock.lock（）；
while（m_work_queue.empty（）&&！m_shutdown）{
m_工作信号。等待（锁定）；
}
如果（！m_work_queue.empty（））{
//（工艺工作…）
继续；
}
//如果没有剩余工作并设置了关闭标志，则退出。
如果（m_关机）返回；
}
}

你也许可以通过以下方式逃脱：

std::atomic<bool> stop_thread = false;

void SomeMethod()
{
  while( !stop_thread )
  {
    .... //Does some work
    boost::this_thread::sleep(boost::posix_time::milliseconds(5000)); //sleep for 5 seconds
  }
}

void stopThread()
{
  stop_thread = true;

  // join thread (wait for it to stop.)
  t->join();
}

std:：原子停止线程=false；
void方法（）
{
而（！停止线程）
{
..//做一些工作
boost:：this_线程：：sleep（boost:：posix_时间：：毫秒（5000））；//睡眠5秒
}
}
void stopThread（）
{
停止线程=真；
//加入线程（等待它停止。）
t->join（）；
}

---

让我告诉你，有时候要安全地离开是不容易的。几周前，我在线程化控制台输入方面遇到了很大的困难。最后，我不得不自己处理原始windows控制台事件并将其转换为击键，这样我就可以同时拦截自定义关机事件。

使用boost:：thread interrupt（）

#include <iostream>
#include <boost/thread.hpp>
#include <boost/chrono.hpp>

class Foo
{
private:
    boost::shared_ptr<boost::thread> t;
public:
    Foo()
    {
        t = boost::make_shared<boost::thread>(&Foo::SomeMethod, this);
    }
    void SomeMethod()
    {
        std::cout << "thread starts" << std::endl;
        while(true) {
            std::cout << "." << std::endl;
            boost::this_thread::sleep(boost::posix_time::seconds(1));
        }
    }
    void stopThread()
    {
        t->interrupt();
        t->join();
        std::cout << "thread stopped" << std::endl;
    }
};

int main()
{
    Foo foo;
    boost::this_thread::sleep(boost::posix_time::seconds(5));
    foo.stopThread();
    return 0;
}

# g++ f.cpp -lboost_thread && ./a.out
thread starts
.
.
.
.
.
thread stopped