Як перевірити, чи все ще працює потік std ::?

Як я можу перевірити, чи std::threadвсе ще працює a (незалежно від платформи)? У ньому бракує timed_join()методу, і joinable()він не призначений для цього.

Я думав зафіксувати мьютекс за допомогою а std::lock_guardу потоці та використати try_lock()метод мьютексу, щоб визначити, чи він все ще заблокований (потік запущений), але мені здається це надмірно складним.

Чи знаєте ви більш елегантний метод?

Оновлення: Щоб бути зрозумілим: я хочу перевірити, чи правильно вийшов потік чи ні. "Висяча" нитка вважається запущеною для цієї мети.

Якщо ви бажаєте використовувати C ++ 11 std::asyncі std::futureдля запуску своїх завдань, тоді ви можете скористатися wait_forфункцією, std::futureщоб перевірити, чи потік все ще працює акуратно, як це:

#include <future>
#include <thread>
#include <chrono>
#include <iostream>

int main() {
    using namespace std::chrono_literals;

    /* Run some task on new thread. The launch policy std::launch::async
       makes sure that the task is run asynchronously on a new thread. */
    auto future = std::async(std::launch::async, [] {
        std::this_thread::sleep_for(3s);
        return 8;
    });

    // Use wait_for() with zero milliseconds to check thread status.
    auto status = future.wait_for(0ms);

    // Print status.
    if (status == std::future_status::ready) {
        std::cout << "Thread finished" << std::endl;
    } else {
        std::cout << "Thread still running" << std::endl;
    }

    auto result = future.get(); // Get result.
}

Якщо вам потрібно використовувати, std::threadтоді ви можете використовувати, std::promiseщоб отримати майбутній об'єкт:

#include <future>
#include <thread>
#include <chrono>
#include <iostream>

int main() {
    using namespace std::chrono_literals;

    // Create a promise and get its future.
    std::promise<bool> p;
    auto future = p.get_future();

    // Run some task on a new thread.
    std::thread t([&p] {
        std::this_thread::sleep_for(3s);
        p.set_value(true); // Is done atomically.
    });

    // Get thread status using wait_for as before.
    auto status = future.wait_for(0ms);

    // Print status.
    if (status == std::future_status::ready) {
        std::cout << "Thread finished" << std::endl;
    } else {
        std::cout << "Thread still running" << std::endl;
    }

    t.join(); // Join thread.
}

Обидва ці приклади виведуть:

Thread still running

Звичайно, це пов’язано з тим, що статус потоку перевіряється перед завершенням завдання.

Але знову ж таки, може бути простіше просто зробити це, як вже згадували інші:

#include <thread>
#include <atomic>
#include <chrono>
#include <iostream>

int main() {
    using namespace std::chrono_literals;

    std::atomic<bool> done(false); // Use an atomic flag.

    /* Run some task on a new thread.
       Make sure to set the done flag to true when finished. */
    std::thread t([&done] {
        std::this_thread::sleep_for(3s);
        done = true;
    });

    // Print status.
    if (done) {
        std::cout << "Thread finished" << std::endl;
    } else {
        std::cout << "Thread still running" << std::endl;
    }

    t.join(); // Join thread.
}

Редагувати:

Існує також std::packaged_taskдля використання з std::threadбільш чистим розчином, ніж використання std::promise:

#include <future>
#include <thread>
#include <chrono>
#include <iostream>

int main() {
    using namespace std::chrono_literals;

    // Create a packaged_task using some task and get its future.
    std::packaged_task<void()> task([] {
        std::this_thread::sleep_for(3s);
    });
    auto future = task.get_future();

    // Run task on new thread.
    std::thread t(std::move(task));

    // Get thread status using wait_for as before.
    auto status = future.wait_for(0ms);

    // Print status.
    if (status == std::future_status::ready) {
        // ...
    }

    t.join(); // Join thread.
}

Найпростішим рішенням є наявність логічної змінної, для якої потік встановлює істину через рівні проміжки часу, і яку перевіряє і встановлює значення false потік, який хоче знати статус. Якщо змінна хибна довгий час, тоді потік більше не вважається активним.

Більш безпечним для потоку способом є наявність лічильника, збільшеного на дочірній потік, і основний потік порівнює лічильник із збереженим значенням, і якщо той самий через занадто довгий час, тоді дочірній потік вважається неактивним.

Зауважте, однак, у C ++ 11 немає способу насправді вбити або видалити завислий потік.

Редагувати Як перевірити, чи правильно вийшов потік чи ні: В основному той самий спосіб, що описаний у першому абзаці; Нехай булева змінна ініціалізується як false. Останнє, що робить дочірній потік, - це встановити для нього значення true. Потім основний потік може перевірити цю змінну, і якщо true, то з’єднати дочірній потік без великих (якщо такі є) блокувань.

Edit2 Якщо потік виходить через виняток, тоді є дві основні функції потоку: Перша має a try- catchвсередині якої вона викликає другу функцію "справжнього" основного потоку. Ця перша основна функція встановлює змінну "have_exited". Щось на зразок цього:

bool thread_done = false;

void *thread_function(void *arg)
{
    void *res = nullptr;

    try
    {
        res = real_thread_function(arg);
    }
    catch (...)
    {
    }

    thread_done = true;

    return res;
}

Цей простий механізм можна використовувати для виявлення фінішної обробки нитки без блокування методу з'єднання.

std::thread thread([&thread]() {
    sleep(3);
    thread.detach();
});

while(thread.joinable())
    sleep(1);

Створіть мьютекс, до якого має доступ як запущений потік, так і викличний потік. Коли запущена нитка запускається, вона блокує мьютекс, а коли закінчується - розблоковує мьютекс. Щоб перевірити, чи потік все ще працює, викличний потік викликає mutex.try_lock (). Повернене значення - це статус потоку. (Просто переконайтеся, що розблокуєте мьютекс, якщо функція try_lock спрацювала)

Одна невелика проблема з цим, mutex.try_lock () поверне значення false між часом, коли потік буде створений, і коли він заблокує мьютекс, але цього можна уникнути, використовуючи трохи більш складний метод.

Ви завжди можете перевірити, чи ідентифікатор потоку відрізняється від побудованого за замовчуванням std :: thread :: id (). Запуск потоку завжди має справжній асоційований ідентифікатор. Намагайтеся уникати занадто багато вишуканих речей :)

Напевно, має змінну, обгорнуту мьютексами, ініційовану до false, яку потік встановлює trueяк останнє, що він робить перед виходом. Чи достатньо цього атомного для ваших потреб?