वर्कर थ्रेड में त्रुटियों से मुख्य धागे की सुरक्षा

Question

पॉज़िक्स धागे का उपयोग करते समय, कार्य धागे के कारण मुख्य थ्रेड को त्रुटियों (जैसे डीरेंसेंस नल पॉइंटर्स, शून्य द्वारा विभाजित) से "सुरक्षित" करने का कोई तरीका है। "वर्कर थ्रेड" से मेरा मतलब है कि pthread_create() द्वारा निर्मित पॉज़िक्स थ्रेड।

दुर्भाग्य से, हम अपवाद उपयोग नहीं कर सकते हैं - तो नहीं "पकड़", आदि

यहाँ मेरी परीक्षण कार्यक्रम (C++) है:

void* workerThreadFunc(void* threadId) { 
    int* a = NULL; 
    *a = 5; //Error (segmentation fault) 
    pthread_exit(NULL); 
} 

int main() { 
    cout << "Main thread start" << endl; 

    pthread_t workerThread; 
    pthread_attr_t attr; 
    pthread_attr_init(&attr); 
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); 
    pthread_create(&workerThread, &attr, workerThreadFunc, (void*)0); 
    pthread_join(workerThread, NULL); 

    cout << "Main thread end" << endl; 
} 

उपरोक्त उदाहरण में, workerThread की वजह से त्रुटि होगा पूरे कार्यक्रम को समाप्त करें। लेकिन मैं इस त्रुटि के बावजूद मुख्य धागा चलाना जारी रखना चाहता हूं। क्या यह हासिल करना संभव है?

Answer 1

मुझे लगता है जैसे आपको कई प्रक्रियाओं का उपयोग करना चाहिए, धागे नहीं। स्वतंत्र प्रक्रियाओं को स्वचालित रूप से अन्य प्रक्रियाओं में होने वाली त्रुटियों से सुरक्षित किया जाता है।

आप थ्रेड के बीच डेटा पास करने के लिए पाइप या साझा मेमोरी (या आईपीसी के अन्य रूपों) का उपयोग कर सकते हैं, जिसमें आपके द्वारा साझा की जाने वाली मेमोरी को साझा करने का अतिरिक्त लाभ होता है, इसलिए कार्यकर्ता "थ्रेड" में एक बग स्टॉम्प नहीं हो सकता मुख्य "थ्रेड" के ढेर पर, क्योंकि यह एक अलग पता स्थान के साथ एक अलग प्रक्रिया है।

थ्रेड उपयोगी हो सकते हैं, लेकिन कई नुकसान के साथ आते हैं, कभी-कभी अलग प्रक्रियाओं में चलना अधिक उपयुक्त होता है।

Answer 2

आपके सिस्टम मान लिया जाये कि एक तरह से की एक POSIX प्रकार में संकेतों का उपयोग करता (कि हालांकि "कोई अपवाद नहीं" नियम के तहत गिर सकता है), तो POSIX का कहना है:

पीढ़ी के समय, एक दृढ़ संकल्प किया जाएगा बनाया गया है कि प्रक्रिया के लिए या प्रक्रिया के भीतर एक विशिष्ट थ्रेड के लिए सिग्नल उत्पन्न किया गया है या नहीं। सिग्नल जो किसी विशेष थ्रेड के लिए जिम्मेदार कुछ क्रियाओं से उत्पन्न होते हैं, जैसे हार्डवेयर गलती, सिग्नल उत्पन्न होने वाले थ्रेड के लिए जेनरेट की जाएगी।

तो तुम SIGSEGV, SIGFPE, एक प्रति pthread आधार पर आदि संभाल कर सकते हैं (लेकिन ध्यान दें कि आप केवल पूरी प्रक्रिया के लिए एक संकेत हैंडलर समारोह सेट कर सकते हैं कि)। तो, आप एक पठार में विफलता से प्रक्रिया को "रोक" से रोक सकते हैं ... एक बिंदु तक। समस्या यह है कि, आपको यह बताने में बहुत मुश्किल हो सकती है कि प्रक्रिया किस स्थिति में है - असफल पर्थ्रेड, और अन्य सभी pthreads - अंदर है। असफल पठार में कई म्यूटेक्स हो सकते हैं। असफल पर्थ्रेड कुछ साझा डेटा संरचनाओं को गड़बड़ में छोड़ सकता है। कौन जानता है कि किस प्रकार की उलझन में चीजें हैं - जब तक कि पर्थ्रेड अनिवार्य रूप से स्वतंत्र न हों। दुर्घटनाग्रस्त होने और जलाए जाने के बजाय "खूबसूरत" बंद करने के लिए अन्य pthreads की व्यवस्था करना संभव हो सकता है। अंत में, अच्छी तरह से परिभाषित राज्य से कम कुछ जारी रखने की कोशिश करने के बजाय, सभी pthreads मृत को रोकने के लिए सुरक्षित हो सकता है। यह पूरी तरह से आवेदन की प्रकृति पर निर्भर करेगा।

कुछ भी नहीं के लिए कुछ भी नहीं है ... धागे एक दूसरे के साथ प्रक्रियाओं की तुलना में अधिक आसानी से संवाद कर सकते हैं, और शुरू करने और रोकने के लिए कम लागत - प्रक्रियाएं अन्य प्रक्रियाओं की विफलता के लिए कम कमजोर हैं।

Answer 3

एक ही रास्ता मैं यह कर के बारे में सोच सकते हैं एक संकेत हैंडलर, जो बजाय कार्यक्रम निरस्त किया जा रहा है, वर्तमान में चल रहे धागा रद्द कर सकता है, कुछ इस तरह दर्ज की है:

void handler(int sig) 
{ 
    pthread_exit(NULL); 
} 

signal(SIGSEGV, handler); 

ध्यान दें, तथापि, यह है pthread_exit के रूप में असुरक्षित सिग्नल हैंडलर के अंदर सुरक्षित सिस्टम कॉल में से एक के रूप में सूचीबद्ध नहीं है। यह काम कर सकता है और ऐसा नहीं हो सकता है, ओ/एस के आधार पर आप चल रहे हैं, और आप किस सिग्नल पर हैंडल कर रहे हैं।