कैसे जांच करें कि क्या एक std :: धागा अभी भी चल रहा है?

Question 1

अगर std::threadअभी भी चल रहा है (एक प्लेटफ़ॉर्म स्वतंत्र तरीके से) मैं कैसे जांच सकता हूं ? यह एक timed_join()विधि का अभाव है और उसके joinable()लिए नहीं है।

मैंने std::lock_guardथ्रेड में एक म्यूटेक्स को लॉक करने के बारे में सोचा और म्यूटेक्स की try_lock()विधि का उपयोग करके यह निर्धारित करने के लिए कि क्या यह अभी भी बंद है (थ्रेड चल रहा है), लेकिन यह मुझे अनावश्यक रूप से जटिल लगता है।

क्या आप एक अधिक सुंदर विधि जानते हैं?

अपडेट: स्पष्ट होने के लिए: मैं यह जांचना चाहता हूं कि धागा सफाई से बाहर निकला है या नहीं। इस उद्देश्य के लिए एक 'लटके' धागे को चालू माना जाता है।

Question 2

यदि आप 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.
}

Question 3

एक आसान उपाय यह है कि बूलियन वैरिएबल हो जो थ्रेड को नियमित अंतराल पर सही सेट करता है, और जो स्टेटस जानना चाहता है उसे थ्रेड द्वारा चेक किया जाता है और गलत पर सेट किया जाता है। यदि चर लंबे समय तक गलत है, तो थ्रेड अब सक्रिय नहीं माना जाता है।

एक अधिक थ्रेड-सुरक्षित तरीका एक काउंटर है जो चाइल्ड थ्रेड द्वारा बढ़ाया जाता है, और मुख्य थ्रेड काउंटर को एक संग्रहीत मूल्य से तुलना करता है और यदि बहुत लंबे समय के बाद भी ऐसा ही है तो बच्चे के थ्रेड को सक्रिय नहीं माना जाता है।

ध्यान दें, वास्तव में मारने या हटाने वाले धागे को हटाने के लिए C ++ 11 में कोई रास्ता नहीं है।

संपादित करें कि कैसे जांच करें कि क्या एक धागा साफ निकला है या नहीं: मूल रूप से पहले पैराग्राफ में वर्णित तकनीक के समान है; एक बूलियन वैरिएबल को गलत के लिए इनिशियलाइज़ किया गया है। आखिरी बात जो बच्चा धागा करता है, वह उसे सच करता है। मुख्य धागा तब उस चर की जांच कर सकता है, और अगर सच है कि बच्चे के धागे पर बहुत कुछ (यदि कोई हो) बिना अवरोध के शामिल हो।

Edit2 यदि थ्रेड अपवाद के कारण बाहर निकलता है, तो दो थ्रेड "मुख्य" फ़ंक्शन हैं: पहले वाले में एक try- एक catchहै जिसके अंदर यह दूसरा "वास्तविक" मुख्य थ्रेड फ़ंक्शन कहता है। यह पहला मुख्य फ़ंक्शन "has_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;
}

Question 4

इस सरल तंत्र को आप सम्मिलित विधि में अवरुद्ध किए बिना किसी धागे के परिष्करण का पता लगाने के लिए उपयोग कर सकते हैं।

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

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

Question 5

एक म्यूटेक्स बनाएं जिसमें रनिंग थ्रेड और कॉलिंग थ्रेड दोनों की पहुंच हो। जब रनिंग थ्रेड शुरू होता है तो यह म्यूटेक्स को लॉक करता है, और जब यह समाप्त होता है तो म्यूटेक्स को अनलॉक करता है। यह जाँचने के लिए कि क्या थ्रेड अभी चल रहा है, कॉलिंग थ्रेड mutex.try_lock () को कॉल करता है। उस का रिटर्न मान थ्रेड की स्थिति है। (यदि try_lock काम किया है तो म्यूटेक्स को अनलॉक करना सुनिश्चित करें)

इसके साथ एक छोटी सी समस्या, mutex.try_lock () थ्रेड के निर्माण के समय के बीच झूठी वापस आ जाएगी, और जब यह म्यूटेक्स को लॉक करता है, लेकिन इससे थोड़ी अधिक जटिल विधि का उपयोग करके बचा जा सकता है।

Question 6

आप हमेशा जांच सकते हैं कि क्या थ्रेड की आईडी std :: थ्रेड :: id () डिफ़ॉल्ट रूप से निर्मित है। एक रनिंग थ्रेड में हमेशा एक वास्तविक संबद्ध आईडी होती है। बहुत अधिक फैंसी सामान से बचने की कोशिश करें :)

Question 7

निश्चित रूप से एक म्यूटेक्स-लिपटे चर को इनिशियलाइज़ किया गया है false, जो कि trueनिकलने से पहले थ्रेड अंतिम चीज़ के रूप में सेट होता है। क्या वह परमाणु आपकी आवश्यकताओं के लिए पर्याप्त है?