हास्केल प्रोग्राम से बाहर निकलने का सबसे अच्छा तरीका क्या है?

Question

मुझे एक प्रोग्राम मिला है जो कई धागे का उपयोग करता है। जैसा कि मैं इसे समझता हूं, जब थ्रेड 0 निकलता है, तो पूरा प्रोग्राम बाहर निकलता है, भले ही किसी भी अन्य धागे जो अभी भी चल रहे हों।

बात यह है कि, इन अन्य धागे में फाइलें खुली हो सकती हैं। स्वाभाविक रूप से, यह अपवाद-हैंडलिंग कोड में लपेटा गया है जो किसी समस्या के मामले में फ़ाइलों को साफ़ रूप से बंद कर देता है। इसका अर्थ यह भी है कि यदि मैं killThread (जिसे throwTo के माध्यम से कार्यान्वित किया गया है) का उपयोग करते हैं, तो फ़ाइल थ्रेड से बाहर होने से पहले बंद होनी चाहिए।

मेरा सवाल है, अगर मैं अन्य थ्रेड को रोकने के प्रयास के बिना थ्रेड 0 बाहर निकलने देता हूं, तो क्या सभी विभिन्न फाइल हैंडल अच्छी तरह से बंद हो जाएंगे? क्या कोई buffered आउटपुट flushed हो जाता है?

संक्षेप में, क्या मैं बस बाहर निकल सकता हूं, या क्या मुझे पहले धागे को मैन्युअल रूप से मारने की आवश्यकता है?

Answer 1

मेरे परीक्षण से, मैं कुछ चीजें की खोज की है:

1. exitFailure और दोस्तों के केवल धागा 0. में काम करते हैं (प्रलेखन वास्तव में ऐसा कहते हैं, अगर आप इसे पढ़ने के परेशान करने के लिए जाना इन कार्यों। एक अपवाद अपने धागा, या अपने पूरे कार्यक्रम को मारता है, तो बस अपवाद है, जो चुपचाप अन्य धागे में अनदेखी कर रहे हैं फेंक देते हैं।)

2. , किसी भी खुले हैंडल नहीं प्लावित कर रहे हैं। यह बेहद परेशान है जब आप बेहद आकस्मिक रूप से यह पता लगाने की कोशिश कर रहे हैं कि आपका प्रोग्राम क्रैश हो गया है!

तो यह ऐसा लगता है कि अगर आप अपने सामान प्लावित से पहले कार्यक्रम बाहर निकलता है, तो आप इस लागू करना चाहते हैं। बस थ्रेड 0 मरने से सामान फ्लश नहीं होता है, कोई अपवाद नहीं फेंकता है, बस चुपचाप अपवाद हैंडलर चलाने के बिना सभी धागे को समाप्त करता है।

Answer 2

आप इसे प्राप्त करने के लिए Control.Concurrent.MVar का उपयोग कर सकते हैं। एक MVar अनिवार्य रूप से एक ध्वज है जो या तो 'खाली' या "पूर्ण" है। एक थ्रेड MVar पढ़ने की कोशिश कर सकता है और यदि यह खाली है तो यह थ्रेड को अवरुद्ध करता है। जहां भी आपके पास एक थ्रेड है जो फ़ाइल IO करता है, उसके लिए MVar बनाएं, और MVar को तर्क के रूप में पास करें। एक सूची में आपके द्वारा बनाए गए सभी MVar रों रखो:

main = do 
    let mvars = sequence (replicate num_of_child_threads newEmptyMVar) 
    returnVals <- sequence (zipWith (\m f -> f m) 
            mvars 
            (list_of_child_threads :: [MVar -> IO a])) 

एक बार एक बच्चे धागा, सभी फाइल संचालन है कि आप के बारे में चिंतित हैं समाप्त हो गया है MVar लिखें। इसके बजाय लेखन killThread की आप

mapM_ takeMVar mvars >> killThread 

कर सकते हैं और जहां-कभी अपने धागा बाहर निकलने अन्यथा, बस सभी MVar रों ले जाएगा।

अधिक जानकारी के लिए documentation on GHC concurrency देखें।