जारी रखने से पहले थ्रेड के लिए कैसे इंतजार करें?

मेरे पास .NET CF 2.0 पर थ्रेड शुरू करने के लिए कुछ कोड है:

ThreadStart tStart = new ThreadStart(MyMethod);
Thread t = new Thread(tStart);
t.Start();

अगर मैं इसे लूप के अंदर बुलाता हूं तो आइटम ऑर्डर से बाहर हो जाते हैं। t.Start() के बाद प्रतीक्षा कैसे करें, ताकि थ्रेड पर काम कोड जारी होने से पहले पूरा हो जाए? मैन्युअल रूप से धागे बनाने से शुरू करने के लिए BeginInvoke / EndInvoke बेहतर विकल्प होगा?

0
ro fr bn

3 उत्तर

अगर मैं इसे ठीक से पढ़ रहा हूं, तो आप थ्रेड के गुच्छा पर काम आइटम शुरू कर रहे हैं, लेकिन आप चिंतित हैं कि थ्रेड ऑर्डर से बाहर हो रहे हैं, और जब तक प्रत्येक थ्रेड शुरू नहीं हुआ तब तक इंतजार करना पसंद करेंगे?

यदि यह मामला है तो मुझे यकीन नहीं है कि आप प्रति कार्य आइटम क्यों थ्रेड बना रहे हैं। शायद आप विस्तार कर सकते हैं?

अगर आपको धागे को पूरा करने के लिए इंतजार करने की ज़रूरत है तो आप बस ऐसा कर सकते हैं:

t.Join();
0
जोड़ा

धागे को खत्म करने का इंतजार करने का एक अन्य तरीका एक AutoResetEvent का उपयोग कर रहा है।

private readonly AutoResetEvent mWaitForThread = new AutoResetEvent(false);

private void Blah()
{
    ThreadStart tStart = new ThreadStart(MyMethod);
    Thread t = new Thread(tStart);
    t.Start();

    //... (any other things)
    mWaitForThread.WaitOne();
}

private void MyMethod()
{
     //... (execute any other action)
     mWaitForThread.Set();
}
0
जोड़ा

धागे पर लगाने के लिए आपको कितना आदेश चाहिए? यदि कोड जारी रखने से पहले आपको लूप में शुरू होने वाले सभी कामों की आवश्यकता है, लेकिन आपको लूप के भीतर काम के आदेश की परवाह नहीं है, तो कॉलिंग का जवाब उत्तर है। केविन केनी के उत्तर में अधिक जानकारी जोड़ने के लिए, आपको लूप को बाहर में शामिल होना चाहिए। इसका मतलब है कि आपको शुरू किए गए धागे के संदर्भ रखने के लिए संग्रह की आवश्यकता होगी:

// Start all of the threads.
List<thread> startedThreads = new List<thread>();
foreach (...) {
  Thread thread = new Thread(new ThreadStart(MyMethod));
  thread.Start();
  startedThreads.Add(thread);
}

// Wait for all of the threads to finish.
foreach (Thread thread in startedThreads) {
  thread.Join();
}

इसके विपरीत, यदि आप लूप के अंदर शामिल हों, तो परिणाम मूल रूप से धागे का उपयोग न करने जैसा ही होगा। लूप बॉडी का प्रत्येक पुनरावृत्ति थ्रेड बनायेगा और शुरू करेगा लेकिन फिर तुरंत इसमें शामिल होगा और इसे समाप्त करने की प्रतीक्षा करेगा।

यदि व्यक्तिगत धागे कुछ परिणाम उत्पन्न करते हैं (उदाहरण के लिए लॉग में एक संदेश लिखें) तो संदेश अभी भी आदेश से बाहर दिखाई दे सकते हैं क्योंकि धागे के बीच कोई समन्वय नहीं है। मॉनिटर के साथ समन्वय करके धागे को अपने परिणामों को आउटपुट करना संभव है।

0
जोड़ा