如何停止線程？

Question

嗨，大家好，我開始線程這樣的代碼：

Thread[] thr; 
    private void button1_Click(object sender, EventArgs e) 
    { 
     decimal value = numericUpDown2.Value; 
     int i = 0; 
     threads_count = (int)(value); 
     thr = new Thread[threads_count]; 
     for (; i < threads_count; i++) 
     { 
      thr[i] = new Thread(new ThreadStart(go)); 
      thr[i].IsBackground = true; 
      thr[i].Start(); 
     } 
    } 

如何停止所有的人，如果我的條件成爲真正的

Answer 1

殘酷的方式（不推薦） - 使用Thread.Abort方法來終止線程。此方法在線程上引發ThreadAbortException。就像這樣：

foreach(Thread thread in thr) 
    thread.Abort(); 

但更好的方法是通知線程有關取消，讓它正確地完成自己的工作。你可以簡單地與.net 4個任務做：

Task[] thr = new Task[threads_count]; 
var source = new CancellationTokenSource(); 

for (int i = 0; i < threads_count; i++) 
{ 
    thr[i] = Task.Factory.StartNew(go, source.Token); 
} 

// later, when condition is met 
source.Cancel(); 

這裏是取消應該什麼樣子：

private static void go(object obj) 
{ 
    CancellationToken token = (CancellationToken)obj; 
    while (true) 
    { 
     if (token.IsCancellationRequested) 
      return; 

     // do some work 
    } 
} 

Answer 2

簡單的答案是，使用線程中止（）方法，但您的代碼不真的說清楚什麼條件，

什麼循環測試與條件？爲什麼你需要中止一個線程？我問的有可能是一個更好的辦法。如果你想知道如何優雅地終止線程來處理這個

Answer 3

，我建議你去看一下以下example on MSDN：

using System; 
using System.Threading; 

public class Worker 
{ 
    public void DoWork() 
    { 
     while (!_shouldStop) 
     { 
      Console.WriteLine("worker thread: working..."); 
     } 
     Console.WriteLine("worker thread: terminating gracefully."); 
    } 
    public void RequestStop() 
    { 
     _shouldStop = true; 
    } 
    // Volatile is used as hint to the compiler that this data 
    // member will be accessed by multiple threads. 
    private volatile bool _shouldStop; 
} 

public class WorkerThreadExample 
{ 
    static void Main() 
    { 
     Worker workerObject = new Worker(); 
     Thread workerThread = new Thread(workerObject.DoWork); 
     workerThread.Start(); 
     Console.WriteLine("main thread: Starting worker thread..."); 

     while (!workerThread.IsAlive); // Loop until worker thread activates 

     // Put the main thread to sleep for 1 millisecond to 
     // allow the worker thread to do some work: 
     Thread.Sleep(1); 

     workerObject.RequestStop(); 

     // Use the Join method to block the current thread 
     // until the object's thread terminates. 
     workerThread.Join(); 
     Console.WriteLine("main thread: Worker thread has terminated."); 
    } 
} 

Answer 4

你可以使用CancellationToken來指示操作何時應該停止。

1. 創建CancellationTokenSource如您在按鈕單擊處理程序初始化類的實例字段。

2. 在你的後臺方法定期檢查Token的IsCancellationRequested財產令牌源，或致電ThrowIfCancellationRequested()如果你希望它只是拋出一個異常，如果它被取消。

3. 當您想要停止線程在令牌源上調用Cancel。

Answer 5

許多答案說中止線程。 除非是緊急情況，並且您正在關閉應用程序，否則絕不要中止線程。

CLR保證其內部數據結構不會被線程中止破壞。 這是CLR針對線程中止所做的唯一（*）保證。它具體做不是保證：

• 線程實際上會中止。線程可以防止被終止。
• CLR中的任何數據結構而不是本身都不會被破壞。在關鍵操作的中間線程中止會使BCL數據結構或用戶數據結構處於任意不一致的狀態。這會在以後神祕地崩潰你的程序。
• 鎖將被釋放。中止線程可能會導致永久保持鎖定，導致死鎖，等等。

在情況下，我沒有說清楚：它是瘋狂危險中止線程，你應該只有這樣做，當所有的選擇更糟。

那麼，如果你想啓動一個線程，然後乾淨地關閉它呢？

首先，不要這樣做。首先不要啓動線程。用取消令牌啓動Task<T>，當您想關閉它時，發出取消令牌的信號。

如果你確實需要啓動一個線程，那麼啓動這個線程使得主線程和工作線程可以乾淨而安全地進行通信。「我希望你在這個時候乾淨地關閉自己」。

如果你不知道如何做，那麼停止編寫多線程代碼，直到你學會如何做到這一點。

---

（*）這是一個小小的謊言; CLR也對線程中止和特殊代碼區域（如約束執行區域和最終塊）的交互作出了一定的保證。

Answer 6

這是Windows窗體代碼，其中：

• 1）在點擊開始按鈕，主線程創建另一個線程
• 2）再創建線程創建更多的線程。

• 3）單擊停止按鈕時，首先最後一個線程應該終止然後由主線程創建的線程應該終止。

  namespace Thread_TerminateProblem 
  {  
      public partial class Form1 : Form 
      {  
  
  
      private static AutoResetEvent m_ResetEvent = null;     
      private static ManualResetEvent m_ResetEvent_Thread = new ManualResetEvent(false); 
      enum ServiceState { Start, Stop }; 
      bool flag = false; 
      int x = 0; 
      ServiceState _state; 
      public Form1() 
      { 
       InitializeComponent(); 
      } 
  
      private void btnStart_Click(object sender, EventArgs e) 
      { 
       flag = true; 
       _state = ServiceState.Start; 
       m_ResetEvent = new AutoResetEvent(true);    
       Thread t1 = new Thread(fun_Thread1); 
       t1.Start(); 
       t1.Name = "Thread1";    
      } 
  
      private void btnStop_Click(object sender, EventArgs e) 
      { 
       _state = ServiceState.Stop; 
       m_ResetEvent.Set();   
      } 
  
  
      private void fun_Thread1() 
      { 
       while (true) 
       {        
        m_ResetEvent.WaitOne();     
        switch (_state) 
        { 
         case ServiceState.Start: 
          {        
           Thread t = new Thread(fun_Thread2); 
           t.Start(); 
           t.Name = "Thread2"; 
           break; 
          } 
         case ServiceState.Stop: 
          { 
           m_ResetEvent_Thread.Set(); 
           flag = true; 
           break; 
          } 
        } 
        // When the child Thread terminates, Then only this thread should terminate 
        if (flag == true) 
        { 
         // Waiting for notification from child Thread 
         notifyParent.WaitOne(); 
         Thread.Sleep(100); 
         break; 
        }     
        m_ResetEvent.Reset();        
       }    
      } 
  
      private static ManualResetEvent notifyParent = new ManualResetEvent(false); 
  
      private void fun_Thread2() 
      { 
       while (true) 
       { 
        if (m_ResetEvent_Thread.WaitOne(1, false)) 
        { 
         notifyParent.Set(); 
         break; 
        } 
        x++;     
       } 
      }  
  } 
  

  }