スレッドが完了していることを確認するにはどうすればよいですか？

Question

私はこれに多くの問題を抱えています。

public class Test { 
    Thread t; 

    public Test() { 
     t = new Thread(ThreadFunction); 
    } 

    public void Start() { 
     t.Start(); 
    } 

    private void ThreadFunction() { 
     Thread.Sleep(5000); 
     Console.WriteLine("Function Complete"); 
    }  
} 


public static class Main { 
    public Main() { 
     Test test = new Test(); 
     test.Start(); 

     // sleep longer than my worker so it finishes 
     Thread.Sleep(10000); 

     // a place to place a breakpoint 
     bool breakPointHere = true; 
    }   
} 

は今、私はにconsole.logの出力を参照してください、私はテストのスレッドオブジェクトを検査するとき、私はとThreadStatus = TheadStatus.Running、IsAliveのはまだ本当であることがわかります。この例を考えてみましょう。どうしてこれなの？私は、スレッドが本当に完全であることを検出したいと思いますが、ThreadFunction（）が完了してもそれがどのように実行されていると考えられるのか混乱していますか？

EDIT 2：

私は最終的に、コードを更新、原因を突き止め、そして自分の質問

using System; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading; 
using System.Threading.Tasks; 


namespace ConsoleApplication1 { 
    public abstract class Worker { 
     protected bool shutdown; 
     protected Thread t; 

     private bool _isStopped = true; 
     public bool IsStopped { 
      get { 
       return t.ThreadState == ThreadState.Stopped; 
      } 
     } 

     private bool _isPaused = false; 
     public bool IsPaused { 
      get { 
       return _isPaused; 
      } 
     } 

     private string stringRepresentation; 

     public Worker() { 
      t = new Thread(ThreadFunction); 
      stringRepresentation = "Thread id:" + t.ManagedThreadId; 
      t.Name = stringRepresentation; 
     } 


     public void Start() { 
      OnBeforeThreadStart(); 
      t.Start(); 
     } 

     public void ScheduleStop() { 
      shutdown = true; 
     } 

     public void SchedulePause() { 
      OnPauseRequest(); 
      _isPaused = true; 
     } 

     public void Unpause() { 
      _isPaused = false; 
     } 

     public void ForceStop() { 
      t.Abort(); 
     } 


     /// <summary> 
     /// The main thread loop. 
     /// </summary> 
     private void ThreadFunction() { 
      OnThreadStart(); 
      while (!shutdown) { 
       if (!IsPaused) { 
        if (!OnLoop()) { 
         break; 
        } 
       } 
       Thread.Sleep(1000); 
      } 
      OnShutdown(); 
     } 

     public abstract void OnBeforeThreadStart(); 
     public abstract void OnThreadStart(); 
     public abstract bool OnLoop(); 
     public abstract void OnShutdown(); 
     public abstract void OnPauseRequest(); 


     public override string ToString() { 
      return stringRepresentation; 
     } 
    } 


    public class Test : Worker { 
     public override void OnBeforeThreadStart() { 
      Log.WriteLine(this + ": Thread about to be started..."); 
     } 

     public override void OnThreadStart() { 
      Log.WriteLine(this + ": Thread Started!"); 
     } 

     public override bool OnLoop() { 
      Log.WriteLine(this + ": I am doing the things..."); 
      return true; 
     } 

     public override void OnShutdown() { 
      Log.WriteLine(this + ": Shutting down!"); 
     } 

     public override void OnPauseRequest() {    
     } 
    } 



public static class Log { 
    public delegate void LogDelegate(string text, string eventTime, Severity severity); 

    public static event LogDelegate OnWriteLine; 

    private static Queue<string> _pendingFileWrites = new Queue<string>(); 


    public enum Severity { 
     Info, 
     Warning, 
     Error 
    } 


    public static void WriteLine(object line, Severity severity = Severity.Info) { 
     string eventTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"); 
     string formatted = "[" + eventTime + "]: " + line; 
     Console.WriteLine(formatted); 

     lock (_pendingFileWrites) { 
      _pendingFileWrites.Enqueue(formatted); 
     } 

     if (OnWriteLine != null) { 
      // this is the offending line: 
      OnWriteLine.Invoke((string)line, eventTime, severity); 
     } 
    } 


    public static void WriteToFile(string path) { 
     lock(_pendingFileWrites) { 
      StreamWriter sw = File.AppendText(path);   
      while(_pendingFileWrites.Count > 0) { 
       sw.WriteLine(
        _pendingFileWrites.Dequeue() 
       ); 
      } 
      sw.Close(); 
     } 
    } 
} 



    class Program { 
     static void Main(string[] args) { 
      List<Test> tests = new List<Test>(); 
      for(int i = 0; i < 10; i++) { 
       Test test = new Test(); 
       test.Start(); 
       tests.Add(test); 
      } 

      // sleep a little bit so they do the things 
      Thread.Sleep(10000); 

      foreach (Test test in tests) { 
       test.ScheduleStop(); 
      } 

      bool allStopped; 
      do { 
       allStopped = true; 
       foreach (Test test in tests) { 
        if (!test.IsStopped) { 
         allStopped = false; 
         break; 
        } 
       } 
      } while (!allStopped); 

      Console.WriteLine("Done!"); 

      // a place to place a breakpoint 
      bool breakPointHere = true; 
     } 
    } 
} 

Answer 1

にお答えするつもりですあなたが本当にあなたのスレッドを待つスリープする必要がありますか終わる？ あなたがThread.Join()

public static class Main { 
    public Main() { 
     Test test = new Test(); 
     test.Start(); 

     test.Join(); // Waits for test to complete 
     bool breakPointHere = true; 
    }   
} 

Answer 2

を使用されるだろう、より良く、より堅牢なソリューションをしない場合、私は.IsAliveは本当だろうと信じてあなたを導くあなたのオリジナルのテストは、私はあなたにあなたのプログラムを微調整し、それにいくつかの欠陥を持っていたと思いますそれをコンパイルし、作成したスレッドを見ることができるようにするために、以下に質問してください。ここ

public class Program 
{ 
    public class Test 
    { 
     Thread t; 

     public Test() 
     { 
      t = new Thread(ThreadFunction); 
      t.Name = "TestThread"; 
     } 

     public void Start() 
     { 
      t.Start(); 
     } 

     private void ThreadFunction() 
     { 
      Thread.Sleep(5000); 
      Console.WriteLine("Function Complete"); 
     } 
    } 


    public static void Main() 
    { 
     Test test = new Test(); 
     test.Start(); 

     // sleep longer than my worker so it finishes 
     Thread.Sleep(10000); 

     // a place to place a breakpoint 
     bool breakPointHere = true; 
    } 
} 

ここThreadFunction

内部から実行中のスレッドのスクリーンショットは、プログラムの終わりがあることを

お知らせからのスクリーンショットです"TestThread"スレッドはありません。ここで

は、地元の人々の窓からスクリーンショット

IsAliveがfalseです。

Answer 3

だから、私の問題は私の伐採方法がそうのようなUIスレッド関数を呼び出したということであったことが判明：呼び出し（）ラインで

private void LogToForm(object line, string eventTime, Log.Severity severity) { 
      if (dataGridView_LogInfo.InvokeRequired) { 
       dataGridView_LogInfo.Invoke (
        new Action<object, string, Log.Severity>(LogtoFormCallback), 
        new object[] { line, eventTime, severity } 
       ); 

      } else { 
       LogtoFormCallback(line, eventTime, severity); 
      } 
     } 

、スレッドは永久にハングアップするでしょう。解決策は、代わりにBeginInvoke（）で置き換えることでした。

編集：また、私の例は/これはかなり悪いです。基本的なレベルでスレッドを理解していないと思っていて、私の例では十分だったはずです。うまくいけば、誰かがこれを考えても同じ理由でこのソリューションを試すことができます。