हो सकता है मेरे पास एक प्रोग्राम है जो थ्रेड शुरू करता है (pthreads का उपयोग करके) जो शेष कार्यक्रम के लिए कुछ पृष्ठभूमि कार्य करेगा। मुख्य कार्यक्रम एक टर्मिनल में चलाया जाता है और एक सामान्य उपयोग-केस इसे बंद करने से पहले इसे Ctrl-C का उपयोग करके बाहर निकलने से पहले बंद करना होता है। किसी ने मुझे उन धागे के अलग-अलग होने के लिए कहा जिन्हें मैं लाश बनने के लिए प्रेरित करता हूं। मैंने पहले इस समस्या के बारे में सोचा नहीं था और मैं आम तौर पर बहु-थ्रेडेड प्रोग्रामिंग में नौसिखिया हूं। मैंने जो कुछ भी उम्मीद कर रहा हूं वह एक छोटा, लेकिन पूर्ण, और आत्मनिर्भर परीक्षण कार्यक्रम है जो वास्तविक कार्यक्रम के व्यवहार की नकल कर सकता है।क्या यह धागा एक ज़ोंबी
नीचे दिए गए कोड में, क्या स्पॉन्टेड थ्रेड का ज़ोंबी बनने का खतरा है? याद रखें कि प्रोग्राम को Ctrl-C का उपयोग करके मार दिया जा सकता है, शायद यह एक विशेष परिदृश्य है, मुझे इसके बारे में निश्चित नहीं है।
अभी, धागा MyThread ऑब्जेक्ट को हटा दिए जाने के बाद चल रहा है। यह वास्तव में एक समस्या नहीं है, क्योंकि वास्तविक कार्यक्रम में, MyThread ऑब्जेक्ट को नष्ट कर दिया गया है जैसे प्रोग्राम किसी भी तरह से बाहर निकलने वाला है। मैं सिर्फ यह जानना चाहता हूं कि माता-पिता के जाने के बाद थ्रेड सिस्टम में ज़ोंबी बनने का जोखिम कभी नहीं है।
मुझे लगता है कि मेरे पास एक म्यूटेक्स-संरक्षित चर हो सकता है जिसे मैं थ्रेड func में जांचता हूं कि मुझे यह बताने के लिए कि क्या मुझे बाहर निकलना चाहिए, और मैं इस चर को MyThread विनाशक में सत्य में सेट कर सकता हूं, लेकिन शायद मैं नहीं ऐसा करने की ज़रूरत है? क्षमा करें, थोड़ा लंबा हो गया, पढ़ने के लिए धन्यवाद और किसी भी मदद के लिए अग्रिम धन्यवाद!
#include <iostream>
#include <pthread.h>
#include <unistd.h>
class MyThread
{
public:
MyThread() : is_running(false) {}
void Run()
{
if (!is_running) {
if (pthread_create(&thread, NULL,
(void * (*)(void *))RunThread,
NULL) == 0) {
is_running = true;
}
else {
std::cerr << "pthread_create() failed." << std::endl;
}
}
else {
std::cout << "The thread was already running." << std::endl;
}
}
private:
static void * RunThread(void */*arg*/)
{
while (true) {
sleep(1);
std::cout << "Hello from RunThread" << std::endl;
}
return NULL;
}
pthread_t thread;
bool is_running;
};
int main()
{
MyThread *thread = new MyThread;
thread->Run();
std::cout << "Going to sleep for five seconds." << std::endl;
sleep(5);
std::cout << "No longer asleep, deleting thread object." << std::endl;
delete thread;
std::cout << "Hit enter to exit program." << std::endl;
std::cin.get();
return 0;
}
http://stackoverflow.com/questions/7285109/unix-zombies-and-daemons/7285149#7285149 –
आपकी मदद के लिए जल्दी और संक्षेप में धन्यवाद। मुझे उम्मीद है कि मैंने अपने स्टैकओवरफ्लो कर्तव्यों को किया जैसा मुझे करना चाहिए। –
यदि कोई पैरेंट चला गया है तो एक प्रक्रिया ज़ोंबी नहीं बनती है। यदि माता-पिता मर जाता है, तो प्रक्रिया को तत्काल init (pid 1) द्वारा विरासत में प्राप्त किया जाता है और इसे पूरा होने पर इसकाटा जाएगा। एक प्रक्रिया केवल एक ज़ोंबी बन जाती है अगर यह समाप्त हो जाती है, जबकि उसके माता-पिता अभी भी जिंदा हैं, और माता-पिता इसे काट नहीं सकते (प्रतीक्षा() या प्रतीक्षापिप() के माध्यम से)। –