थ्रेड को रोकने/फिर से शुरू करने के लिए

Question

मैं थ्रेड को रोक/फिर से कैसे शुरू कर सकता हूं? एक बार जब मैं Join() धागा करता हूं, तो मैं इसे पुनरारंभ नहीं कर सकता। तो मैं थ्रेड कैसे शुरू कर सकता हूं और बटन को 'रोक' दबाए जाने पर इसे रोक सकता हूं, और फिर से शुरू होने पर बटन फिर से शुरू कर सकता है?

यह धागा केवल एक चीज करता है, लेबल नियंत्रण में कुछ यादृच्छिक पाठ दिखाता है।

Answer 1

शायद ManualResetEvent एक अच्छा विकल्प है। एक छोटी उदाहरण:

private static EventWaitHandle waitHandle = new ManualResetEvent(initialState: true); 

// Main thread 
public void OnPauseClick(...) { 
    waitHandle.Reset(); 
} 

public void OnResumeClick(...) { 
    waitHandle.Set(); 
} 

// Worker thread 
public void DoSth() { 
    while (true) { 
    // show some random text in a label control (btw. you have to 
    // dispatch the action onto the main thread) 
    waitHandle.WaitOne(); // waits for the signal to be set 
    } 
} 

Answer 2

मेरा सुझाव है कि आप Threading in C#, by Joe Albahari, पढ़ने के लिए विशेष रूप से Suspend and Resume अनुभाग:

एक धागा स्पष्ट रूप से निलंबित किया जा सकता है और पदावनत तरीकों Thread.Suspend और Thread.Resume के माध्यम से शुरू हुआ। यह तंत्र अवरुद्ध करने के लिए पूरी तरह से अलग है। दोनों प्रणालियां स्वतंत्र हैं और समानांतर में संचालित होती हैं।

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

.NET 2.0, को निलंबित और फिर से शुरू करें अमान्य हो जाने, उनके उपयोग खतरे मनमाने ढंग से एक और धागा निलंबित में निहित की वजह से हतोत्साहित से

। यदि किसी महत्वपूर्ण संसाधन पर लॉक रखने वाला धागा निलंबित कर दिया गया है, तो संपूर्ण एप्लिकेशन (या कंप्यूटर) डेडलॉक कर सकता है। यह एबॉर्ट को कॉल करने से कहीं अधिक खतरनाक है - जिसके परिणामस्वरूप अंततः ब्लॉक में कोड के आधार पर ऐसे किसी भी ताले को जारी किया जा सकता है (कम से कम सैद्धांतिक रूप से)।

Answer 3

यह सबसे अच्छा विचार मैन्युअल निलंबित नहीं कर रहा है करने के लिए और धागे को फिर से शुरू। हालांकि, आप आसानी से थ्रेड सिंक्रनाइज़ेशन प्राइमेटिव्स (ManualResetEvent)

this question पर एक नज़र डालें, तो आप इसे उपयोगी पा सकते हैं।

लेकिन मेरा मानना ​​है कि आप समय-समय पर टाइमर का उपयोग कर 'लेबल नियंत्रण में यादृच्छिक पाठ दिखाने' के अपने लक्ष्य को आसानी से प्राप्त कर सकते हैं।

यहाँ आप फिर से timer.Stop() को फोन करके यह रोक सकते हैं और उसके बाद फिर से शुरू करने timer.Start()DispatcherTimer

var timer = new DispatcherTimer(); 
timer.Tick += (s, e) => Label.Text = GetRandomText(); 
timer.Interval = TimeSpan.FromMilliseconds(500); 
timer.Start(); 

का उपयोग कर एक त्वरित उदाहरण है।

Answer 4

यहां दो तरीके हैं जो मेरे लिए काम करते हैं। दोनों मानते हैं कि कार्यकर्ता धागे का अपना प्रसंस्करण पाश है।

1. का उपयोग कर, धागा एक कॉलबैक आह्वान जा रहा
2. माता पिता संकेत करने के लिए यह

सांत्वना आवेदन उदाहरण नीचे दोनों दृष्टिकोण से पता चलता धागा के वर्ग पर एक विधि आह्वान है रखने के लिए अनुमति का अनुरोध करना है रोकने/जारी रखने के लिए एक कॉलबैक, और रोकने के लिए एक कार्यकर्ता विधि।कॉलबैक विधि का एक अन्य लाभ यह है कि जारी रखने की अनुमति की जांच करते समय बैक स्टेटस अपडेट पास करना भी सुविधाजनक है।

using System; 
using System.Threading; 

namespace ConsoleApplication7 
{ 
    class Program 
    { 
     static bool keepGoing; 
     static void Main(string[] args) 
     { 
      keepGoing = true; 
      Worker worker = new Worker(new KeepGoingDelegate(KeepGoing)); 
      Thread thread = new Thread(worker.DoWork); 
      thread.IsBackground = true; 
      thread.Start(); 

      while (thread.ThreadState != ThreadState.Stopped) 
      { 
       switch (Console.ReadKey(true).KeyChar) 
       { 
        case 'p': 
         keepGoing = false; 
         break; 
        case 'w': 
         keepGoing = true; 
         break; 
        case 's': 
         worker.Stop(); 
         break; 
       } 
       Thread.Sleep(100); 
      } 
      Console.WriteLine("Done"); 
      Console.ReadKey(); 
     } 

     static bool KeepGoing() 
     { 
      return keepGoing; 
     } 
    } 

    public delegate bool KeepGoingDelegate(); 
    public class Worker 
    { 
     bool stop = false; 
     KeepGoingDelegate KeepGoingCallback; 
     public Worker(KeepGoingDelegate callbackArg) 
     { 
      KeepGoingCallback = callbackArg; 
     } 

     public void DoWork() 
     { 
      while (!stop) 
      { 
       Console.Write(KeepGoingCallback()?"\rWorking":"\rPaused "); 

       Thread.Sleep(100); 
      } 
      Console.WriteLine("\nStopped"); 
     } 

     public void Stop() 
     { 
      stop = true; 
     } 
    } 
}