आप कैसे निर्धारित करते हैं कि बाल धागे

Question

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

Answer 1

आप Process.GetCurrentProcess() का उपयोग कर सकते हैं। Threads.Count।

Answer 2

यहां कई दृष्टिकोण हैं, लेकिन संभवतः उनमें से अधिकतर कुछ करने के लिए निष्पादित धागे को बदलने के लिए नीचे आते हैं (सफलता या अपवाद के माध्यम से, जिसे आप वैसे भी नहीं करना चाहते हैं)। काउंटर को कम करने के लिए Interlock.Decrement का उपयोग करने के लिए एक सरल दृष्टिकोण हो सकता है - और यदि यह शून्य है (या -व, जो शायद एक त्रुटि का मतलब है) ManualResetEvent या Monitor.Pulse किसी ऑब्जेक्ट को छोड़ दें; किसी भी मामले में, मूल धागा उस ऑब्जेक्ट पर प्रतीक्षा करेगा। इस तरह के कई दृष्टिकोण discussed here हैं।

बेशक, 4.0 में टीपीएल बिट्स को देखना आसान हो सकता है, जो यहां बहुत सारे नए विकल्प प्रदान करता है (कम से कम चीजें जैसे Parallel.For PLINQ में)।

यदि आप सिंक्रनाइज़ किए गए कार्य कतार का उपयोग कर रहे हैं, तो यह कतार को बंद करने (नाली) को सेट करना भी संभव हो सकता है, और बस कतार खाली होने की प्रतीक्षा करें? धारणा यहाँ जा रहा है कि अपने कार्यकर्ता धागे की तरह कुछ कर रहे हैं:

जिस स्थिति में

T workItem; 
while(queue.TryDequeue(out workItem)) { // this may block until either something 
    ProcessWorkItem(workItem);   // todo, or the queue is terminated 
} 
// queue has closed - exit the thread 

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

Answer 3

मान लीजिए कि आपके पास धागे की एक सूची है, यहां दो दृष्टिकोण हैं।

समाधान पहले:

एक समयावधि पैरामीटर के साथ उपयोग Thread.Join() बदले में प्रत्येक थ्रेड के साथ एक समय होनेवाला बनाना। वापसी मूल्य आपको बताता है कि धागा समाप्त हो गया है या नहीं।

समाधान दूसरा:

चेक Thread.IsAlive() अगर धागा अभी भी चल रहा है देखने के लिए।

किसी भी स्थिति में, सुनिश्चित करें कि आपका मुख्य धागा प्रोसेसर समय को चलने वाले धागे में उत्पन्न करता है, अन्यथा आपका प्रतीक्षा लूप अधिकांश/सभी CPU का उपभोग करेगा और आपके कार्यकर्ता धागे को भूखा करेगा।

Answer 4

आप Thread.Join() का उपयोग कर सकते हैं। Join विधि थ्रेड तक कॉलिंग थ्रेड को अवरुद्ध कर देगा (जिस पर Join विधि कहा जाता है) समाप्त हो जाता है।

तो यदि आपके पास धागे की एक सूची है, तो आप प्रत्येक थ्रेड पर Join के माध्यम से लूप कर सकते हैं और कॉल कर सकते हैं। जब आप सभी धागे मर जाते हैं तो आप लूप केवल बाहर निकल जाएंगे। कुछ इस तरह:

for(int i = 0 ;i < childThreadList.Count; i++) 
{ 
    childThreadList[i].Join(); 
} 
///...The following code will execute when all threads in the list have been terminated.../// 

Answer 5

मुझे लगता है कि जॉइन() विधि का उपयोग सबसे साफ तरीका है। मैं अक्सर कई धागे का उपयोग करता हूं, और प्रत्येक धागा आम तौर पर अलग-अलग डेटा स्रोतों (इनफॉर्मिक्स, ओरेकल और एसक्यूएल) से डेटा लोड कर रहा है।) ऊपर वर्णित एक साधारण लूप, प्रत्येक थ्रेड ऑब्जेक्ट (जिसमें मैं स्टोर करता हूं) पर जॉइन() को कॉल करना एक साधारण सूची वस्तु) काम करता है !!!

कार्लोस मेरिघे।

Answer 6

मैं धागे की एक HashSet का उपयोग कर पसंद करते हैं:

// create a HashSet of heavy tasks (threads) to run 
HashSet<Thread> Threadlist = new HashSet<Thread>(); 
Threadlist.Add(new Thread(() => SomeHeavyTask1())); 
Threadlist.Add(new Thread(() => SomeHeavyTask2())); 
Threadlist.Add(new Thread(() => SomeHeavyTask3())); 

// start the threads 
foreach (Thread T in Threadlist) 
    T.Start(); 

// these will execute sequential 
NotSoHeavyTask1(); 
NotSoHeavyTask2(); 
NotSoHeavyTask3(); 

// loop through tasks to see if they are still active, and join them to main thread 
foreach (Thread T in Threadlist) 
    if (T.ThreadState == ThreadState.Running) 
    T.Join(); 

// finally this code will execute 
MoreTasksToDo();