Я хочу убить std::thread, используя его объект потока?

Ответ @bamboon хорош, однако я считаю, что он заслуживает более сильного утверждения.

Какой бы язык вы ни использовали, ваша программа будет получать и освобождать ресурсы: память, файловые дескрипторы, ... Для простых программ, которые запускаются одним выстрелом, утечка ресурсов не имеет большого значения: когда программа завершается, современные ОС автоматически забирают ресурсы обратно. ; однако для долго работающих программ основным требованием является отсутствие утечки ресурсов или, по крайней мере, повторения.

Поэтому вас с самого начала должны были научить тому, что когда вы приобретаете ресурс, вы должны обеспечить его освобождение в какой-то момент:

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

    /* do something */

    free(array);
}

Итак, задайте себе вопрос:

• что происходит, когда я убиваю программу?
• что произойдет, когда я убью нить?

Что ж, как мы уже говорили, когда программа завершается, ОС собирает ресурсы обратно, поэтому предполагается (и это некоторое предположение), что вы не получили ресурс в другой системе ИЛИ что эта система хорошо защищена. против такого злоупотребления, ни вреда, ни фола.

Однако, когда вы завершаете поток, программа продолжает работать, поэтому ОС не собирает ресурсы обратно. У вас произошла утечка памяти, вы заблокировали файл для записи, который вы больше не можете разблокировать, ... Вы не должны убивать темы.

В языках более высокого уровня есть способ справиться с этим: исключения. Поскольку программы в любом случае должны быть защищены от исключений, Java (например) уничтожит поток, приостановив его, бросив исключение в точке выполнения и аккуратно размотав стек. Однако в C++ такой возможности пока нет.

Это невозможно? Нет, очевидно, нет. На самом деле, вы могли бы прекрасно использовать ту же самую идею:

• encapsulate 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

Теперь вы можете просто посыпать свой многопоточный код проверками на прерывание в соответствующих местах.

Вы не можете.

std::threads нельзя прервать. Вы можете использовать boost::thread, который предлагает эту функцию.

Boost делает это, определяя «точки прерывания», на которых завершится поток, если он будет прерван и достигнет такой точки.

Тем не менее, в большинстве случаев размышления о редизайне могут быть самым чистым и простым способом достичь того, чего вы пытаетесь достичь.

Если вы все еще ищете реализацию прерываемых потоков на С++ 11, ознакомьтесь с книгой Энтони Уильямса (владельца потока повышения) "C++ Concurrency in Action". Он проходит базовую реализацию того, как такая вещь может быть достигнута.

std::thread::native_handle дает вам доступ к базовому дескриптору потока для конкретной платформы, который может поддерживать прерывание, однако такой подход делает ваш код непереносимым и, вероятно, никоим образом не чище.