पर्ल में समवर्ती धागे कैसे चलाएं?

Question

निम्नलिखित समवर्ती धागे में चलाने के लिए के रूप में मैं उम्मीद प्रकट नहीं होता है, बल्कि प्रत्येक प्रक्रिया ब्लॉक यह पूरा हो गया है जब तक:

my @arr = (1,2,3,4); 
foreach (@arr) { 
    threads->new(\&doSomething, $_)->join; 
} 

sub doSomething { 
    my $thread = shift; 
    print "thread $thread\n"; 
    sleep(5); 
} 

दूसरे शब्दों में, यह गैर पिरोया संस्करण के समान क्रियान्वित प्रतीत होता है होगा:

my @arr = (1,2,3,4); 
foreach (@arr) { 
    doSomething($_); 
} 

मैं ActivePerl v5.10.1 mswin32-86-बहु धागा

मैं पर्ल में समवर्ती धागे को चलाने के लिए कैसे चल रहा है?

Answer 1

perldoc threads देखें।

समस्या यह है कि join() को थ्रेड पर कॉल करने के लिए प्रतीक्षा करने की प्रतीक्षा है। आप धागे को फेंकना चाहते हैं और उसके बाद जुड़ना चाहते हैं, एक ऑपरेशन के रूप में स्पॉन/शामिल नहीं होना चाहते हैं।

perldoc threads पर एक और नज़र का कहना है:

threads-> सूची()

threads-> सूची (धागे :: सभी)

threads-> सूची (धागे :: चल)

threads-> सूची (धागे :: joinable)

कोई तर्क नहीं (या धागे का उपयोग :: सभी) और एक सूची संदर्भ में, सभी गैर-जुड़े, गैर-पृथक थ्रेड ऑब्जेक्ट्स की एक सूची लौटाती है। एक स्केलर संदर्भ में, इसकी गणना करता है।

एक सच्चे तर्क के साथ

(धागे :: चल उपयोग करते हुए), सभी गैर शामिल हो गए, गैर अलग धागे वस्तुओं कि अभी भी चल रहे की एक सूची देता है।

झूठी बहस (धागे का उपयोग करके :: शामिल करने योग्य) के साथ, चलने वाले सभी गैर-जुड़े, गैर-पृथक धागे की वस्तुओं की एक सूची लौटाती है (यानी, जिसके लिए -> जुड़ें() अवरुद्ध नहीं होंगे)।

आप पाश और सूची धागे के लिए इसका उपयोग कर सकते हैं, जब संभव में शामिल होने, जब तक सभी धागे पूरा कर रहे हैं (और आप शायद एक ऊपरी सीमा जहाँ आप उन्हें मारने और रद्द कर देगा समय तक इंतजार करना चाहता हूँ)

Answer 2

join (न केवल पर्ल में) थ्रेड को थ्रेड कॉलिंग के लिए प्रतीक्षा करने का कारण बनता है। तो आपका उदाहरण धागा पैदा करता है, इसे समाप्त करने की प्रतीक्षा करता है, और उसके बाद एक और धागा पैदा करता है, इसलिए आपको इंप्रेशन मिलता है कि कोई थ्रेड नहीं होता है।

my @arr = (1,2,3,4); 
my @threads; 
foreach (@arr) { 
    push @threads, threads->new(\&doSomething, $_); 
} 
foreach (@threads) { 
    $_->join(); 
} 

Answer 3

आप उन्हें में शामिल होने के बाद, उन्हें नहीं बनाते समय है थ्रेड से उत्पन्न आउटपुट, आप थ्रेड पर -> detach() का उपयोग कर सकते हैं।

मेरा @arr = (1,2,3,4); मेरे @ थ्रेड; foreach (@arr) {
मेरी $ टी = threads-> नई (\ & DoSomething, $ _); $ टी-> अलग करें(); }

धागे पूरा होने के बाद, इसे पुनः दावा किया गया है और आपको इसमें शामिल होने की आवश्यकता नहीं है।

इस मॉडल कार्यकर्ता मक्खियों जो आप आप के लिए वापस रिपोर्ट करने की आवश्यकता नहीं है बनाने के लिए अच्छा है।

Answer 4

आप joinकॉल करनी होगी के बाद उत्पन्न करने वाला सभी थ्रेड:

perl -mthreads -le'$_->join for map threads->new(sub{print"Thread $_";sleep(2)}),1..4' 

Answer 5

आप की परवाह नहीं है, तो

Answer 6

my @arr = (1,2,3,4); 
my @threads; 
foreach (@arr) { 
    push @threads, threads->new(\&doSomething, $_); 
} 
foreach (@threads) { 
    $_->join(); 
} 

उपरोक्त कोड एक छोटे पैमाने पर काम कर रहा है। लेकिन अगर आपके पास धागे या अधिक हैं, तो आपका ओएस स्टॉल करना शुरू हो जाता है।