Question

可能重复：
C++0x thread interruption

我试图通过使用其线程对象来杀死/停止c ++ std :: thread。

我们怎么做？

Answer 1

@ bamboon的答案很好，但我觉得这应该得到更强有力的陈述。

无论您使用何种语言，您的程序都将获取并释放资源：内存，文件描述符......对于一次性触发的简单程序，泄漏资源并不重要：当程序结束时，现代操作系统会自动执行资源回来了;但是对于长期运行的程序，基本要求不是泄漏资源，或者至少不重复。

因此，您应该从一开始就被教导，当您获得资源时，您必须确保它在某一时刻被释放：

void foo(int i) {
    int* array = malloc(sizeof(int) * i);

    /* do something */

    free(array);
}

所以，问问自己这个问题：

当我杀死程序时会发生什么？
当我杀死线程时会发生什么？

好吧，正如我们所说，当一个程序结束时，操作系统会收回资源，所以假设（这是一些假设）你没有在另一个系统上获得资源或者这个系统很好地保护免受这种虐待，没有伤害，没有犯规。

但是，当您终止某个线程时，程序仍会运行，因此操作系统不会收回资源。你忘记了内存，你锁定了一个文件，写不再解锁，... 你不应该杀死线程。

更高级别的语言有办法解决这个问题：例外。因为程序应该是异常安全的，所以Java（例如）会通过暂停它来杀死一个线程，在执行时抛出一个异常，然后轻轻地展开堆栈。但是，C ++中还没有这样的功能。

这不可能吗？不，显然不是。实际上，你可以完全重用同样的想法：

封装std::thread，interruptible_thread类也将包含中断标志
启动时将标志的地址传递给std::thread，并以线程本地方式存储
使用检查点检测代码，检查是否设置了中断标志，以及何时抛出异常

那是：

// Synopsis
class interrupt_thread_exception;
class interruptible_thread;
void check_for_interrupt();

// Interrupt exception
class interrupt_thread_exception: public virtual std::exception {
public:
    virtual char const* what() const override { return "interrupt"; }
}; // class interrupt_thread_exception

// Interruptible thread
class interruptible_thread {
public:
    friend void check_for_interrupt();

    template <typename Function, typename... Args>
    interruptible_thread(Function&& fun, Args&&... args):
        _thread([](std::atomic_bool& f, Function&& fun, Args&&... args) {
                    _flag_ref = &f; fun(std::forward<Args>(args)...);
                },
                _flag,
                std::forward<Function>(fun),
                std::forward<Args>(args)...)
    {}

    bool stopping() const { return _flag.load(); }

    void stop() { _flag.store(true); }

private:
    static thread_local std::atomic_bool* _flag_ref = nullptr;

    std::atomic_bool _flag = false;
    std::thread _thread;
}; // class interruptible_thread

// Interruption checker
inline void check_for_interrupt() noexcept(false) {
    if (not interruptible_thread::_flag_ref) { return; }
    if (not interruptible_thread::_flag_ref->load()) { return; }

    throw interrupt_thread_exception();
} // check_for_interrupt

现在你可以在适当的地方撒上线程代码并检查中断。

Answer 2

你做不到。

std::threads不可中断。您可以使用提供此功能的boost::thread。

Boost通过定义“中断点”来做到这一点，如果线程被中断并且到达这样一个点，线程将在该中断点上结束。

尽管如此，大多数时候考虑重新设计可能是达到你想要实现的目标的最简洁和最简单的方法。

如果您仍在寻找可中断线程的C ++ 11实现，请查看Anthony Williams（提升线程的所有者）一书“C ++ Concurrency in Action”。他经历了如何实现这一目标的基本实现。

std::thread::native_handle使您可以访问可能支持中断的平台特定底层线程句柄，但是这种方法使您的代码不可移植，并且可能不会以任何方式清理。

我想用它的线程对象杀死一个std :: thread？

2 个答案: