จะตรวจสอบได้อย่างไรว่าเธรด std :: ยังทำงานอยู่หรือไม่

ฉันจะตรวจสอบได้อย่างไรว่า a std::threadยังทำงานอยู่ (ในรูปแบบที่ไม่ขึ้นกับแพลตฟอร์ม) มันขาดtimed_join()วิธีการและjoinable()ไม่มีความหมายสำหรับสิ่งนั้น

ฉันคิดว่าจะล็อค mutex ด้วยstd::lock_guardเธรดและใช้try_lock()วิธีการของ mutex เพื่อตรวจสอบว่ามันยังคงถูกล็อกอยู่หรือไม่ (เธรดกำลังทำงานอยู่) แต่ดูเหมือนว่าฉันจะซับซ้อนโดยไม่จำเป็น

คุณรู้วิธีที่หรูหรากว่านี้หรือไม่?

อัปเดต:เพื่อความชัดเจน: ฉันต้องการตรวจสอบว่าเธรดออกอย่างสมบูรณ์หรือไม่ ถือว่าด้าย 'ห้อย' ทำงานเพื่อจุดประสงค์นี้

หากคุณยินดีที่จะใช้ 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.
}

วิธีแก้ปัญหาง่ายๆคือการมีตัวแปรบูลีนที่เธรดตั้งค่าเป็นจริงในช่วงเวลาปกติและจะถูกตรวจสอบและตั้งค่าเป็นเท็จโดยเธรดที่ต้องการทราบสถานะ หากตัวแปรเป็นเท็จสำหรับ long แสดงว่าเธรดจะไม่ทำงานอีกต่อไป

วิธีที่ปลอดภัยต่อเธรดมากขึ้นคือการมีตัวนับที่เพิ่มขึ้นโดยเธรดลูกและเธรดหลักจะเปรียบเทียบตัวนับกับค่าที่เก็บไว้และหากเท่ากันหลังจากนั้นนานเกินไปเธรดลูกจะถือว่าไม่ทำงาน

อย่างไรก็ตามโปรดทราบว่าไม่มีวิธีใดใน C ++ 11 ที่จะฆ่าหรือลบเธรดที่แขวนคอได้

แก้ไขวิธีตรวจสอบว่าเธรดออกอย่างหมดจดหรือไม่: โดยทั่วไปเป็นเทคนิคเดียวกับที่อธิบายไว้ในย่อหน้าแรก กำหนดให้ตัวแปรบูลีนเริ่มต้นเป็นเท็จ สิ่งสุดท้ายที่เธรดย่อยทำคือตั้งค่าเป็นจริง จากนั้นเธรดหลักจะตรวจสอบตัวแปรนั้นได้และหาก true ทำการเข้าร่วมเธรดลูกโดยไม่ต้องบล็อกมาก (ถ้ามี)

แก้ไข 2หากเธรดออกเนื่องจากข้อยกเว้นจะมีฟังก์ชัน "main" สองเธรด: อันแรกมี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 ที่ทั้งเธรดที่รันและเธรดการเรียกใช้สามารถเข้าถึงได้ เมื่อเธรดที่รันอยู่เริ่มต้นมันจะล็อก mutex และเมื่อสิ้นสุดเธรดจะปลดล็อก mutex ในการตรวจสอบว่าเธรดยังทำงานอยู่หรือไม่เธรดการโทรจะเรียกใช้ mutex.try_lock () ค่าที่ส่งคืนคือสถานะของเธรด (ตรวจสอบให้แน่ใจว่าได้ปลดล็อก mutex หาก try_lock ใช้งานได้)

ปัญหาเล็ก ๆ อย่างหนึ่งของปัญหานี้ mutex.try_lock () จะส่งกลับเท็จระหว่างเวลาที่สร้างเธรดและเมื่อล็อก mutex แต่สามารถหลีกเลี่ยงได้โดยใช้วิธีที่ซับซ้อนกว่าเล็กน้อย

คุณสามารถตรวจสอบได้ตลอดเวลาว่า id ของเธรดแตกต่างจาก std :: thread :: id () default ที่สร้างขึ้นหรือไม่ เธรดที่กำลังรันมี id ที่เกี่ยวข้องของแท้เสมอ พยายามหลีกเลี่ยงของแฟนซีมากเกินไป :)

แน่นอนว่าต้องเริ่มต้นตัวแปรที่ห่อหุ้ม mutex ไว้falseซึ่งเธรดจะตั้งค่าtrueเป็นสิ่งสุดท้ายที่ทำก่อนที่จะออก ปรมาณูนั้นเพียงพอสำหรับความต้องการของคุณหรือไม่?