スレッドが.NETで完了するのを待つ方法は？

メインのUIスレッドだけでなく、2つのスレッドが必要なC＃では、これまでスレッドを使用したことがありません。基本的に、私は以下を持っています。

public void StartTheActions()
{
  //Starting thread 1....
  Thread t1 = new Thread(new ThreadStart(action1));
  t1.Start();

  // Now, I want for the main thread (which is calling `StartTheActions` method) 
  // to wait for `t1` to finish. I've created an event in `action1` for this. 
  // The I wish `t2` to start...

  Thread t2 = new Thread(new ThreadStart(action2));
  t2.Start();
}

だから、本質的に、私の質問は、スレッドが終了するのを待つ方法です。これを行う最良の方法は何ですか？

私は利用可能な5つのオプションを見ることができます：

1. Thread.Join

ミッチの答えと同じです。しかし、これによりUIスレッドがブロックされますが、タイムアウトが組み込まれます。

2.を使用 WaitHandle

ManualResetEventWaitHandlejristaが提案するとおりです。

WaitHandle.WaitAll()MTAスレッドが必要なため、複数のスレッドを待機したい場合、デフォルトでは機能しないことに注意してください。Main()メソッドにマークを付けることでこれを回避できますが、これMTAThreadはメッセージポンプをブロックするため、私が読んだことからはお勧めできません。

3.イベントを発生させる

イベントとマルチスレッドについてJon Skeetによるこのページを参照してください。イベントは、ifとの間でサブスクライブ解除される可能性がありますEventName(this,EventArgs.Empty)-以前に発生しました。

（うまくいけば、これらはコンパイルされ、私は試していません）

public class Form1 : Form
{
    int _count;

    void ButtonClick(object sender, EventArgs e)
    {
        ThreadWorker worker = new ThreadWorker();
        worker.ThreadDone += HandleThreadDone;

        Thread thread1 = new Thread(worker.Run);
        thread1.Start();

        _count = 1;
    }

    void HandleThreadDone(object sender, EventArgs e)
    {
        // You should get the idea this is just an example
        if (_count == 1)
        {
            ThreadWorker worker = new ThreadWorker();
            worker.ThreadDone += HandleThreadDone;

            Thread thread2 = new Thread(worker.Run);
            thread2.Start();

            _count++;
        }
    }

    class ThreadWorker
    {
        public event EventHandler ThreadDone;

        public void Run()
        {
            // Do a task

            if (ThreadDone != null)
                ThreadDone(this, EventArgs.Empty);
        }
    }
}

4.デリゲートを使用する

public class Form1 : Form
{
    int _count;

    void ButtonClick(object sender, EventArgs e)
    {
        ThreadWorker worker = new ThreadWorker();

        Thread thread1 = new Thread(worker.Run);
        thread1.Start(HandleThreadDone);

        _count = 1;
    }

    void HandleThreadDone()
    {
        // As before - just a simple example
        if (_count == 1)
        {
            ThreadWorker worker = new ThreadWorker();

            Thread thread2 = new Thread(worker.Run);
            thread2.Start(HandleThreadDone);

            _count++;
        }
    }

    class ThreadWorker
    {
        // Switch to your favourite Action<T> or Func<T>
        public void Run(object state)
        {
            // Do a task

            Action completeAction = (Action)state;
            completeAction.Invoke();
        }
    }
}

_countメソッドを使用する場合は、（安全のため）を使用してインクリメントすることをお勧めします

Interlocked.Increment(ref _count)

スレッド通知にデリゲートとイベントを使用する違いを知りたいのですが、イベントが同期的に呼び出されることだけが違います。

5.代わりに非同期で行う

この質問に対する答えには、この方法でのオプションの非常に明確な説明があります。

間違ったスレッドのデリゲート/イベント

イベント/デリゲートの方法は、イベントハンドラーメソッドがメインのUIスレッドではなく thread1 / thread2にあることを意味します。そのため、HandleThreadDoneメソッドの最上部で元に戻す必要があります。

// Delegate example
if (InvokeRequired)
{
    Invoke(new Action(HandleThreadDone));
    return;
}

追加

t1.Join();    // Wait until thread t1 finishes

あなたがそれを開始した後、それは本質的にメインスレッドで実行するのと同じ結果なので、それはあまり達成されません！

.NETでのスレッド化について理解を深めたい場合は、Joe AlbahariのThreading in C＃ free e-bookを読むことを強くお勧めします。

前の2つの答えはすばらしいもので、単純なシナリオで機能します。ただし、スレッドを同期する方法は他にもあります。以下も機能します：

public void StartTheActions()
{
    ManualResetEvent syncEvent = new ManualResetEvent(false);

    Thread t1 = new Thread(
        () =>
        {
            // Do some work...
            syncEvent.Set();
        }
    );
    t1.Start();

    Thread t2 = new Thread(
        () =>
        {
            syncEvent.WaitOne();

            // Do some work...
        }
    );
    t2.Start();
}

ManualResetEventは、.NETフレームワークが提供する必要があるさまざまなWaitHandleの1つです。それらは、lock（）/ Monitor、Thread.Joinなどのシンプルで非常に一般的なツールよりもはるかに豊富なスレッド同期機能を提供できます。また、2つ以上のスレッドを同期するために使用でき、「マスター」スレッドなどの複雑なシナリオを可能にします複数の「子」スレッド、同期するために互いにいくつかの段階に依存する複数の同時プロセスなどを調整します。

.NET 4から使用する場合、このサンプルは次のことに役立ちます。

class Program
{
    static void Main(string[] args)
    {
        Task task1 = Task.Factory.StartNew(() => doStuff());
        Task task2 = Task.Factory.StartNew(() => doStuff());
        Task task3 = Task.Factory.StartNew(() => doStuff());
        Task.WaitAll(task1, task2, task3);
        Console.WriteLine("All threads complete");
    }

    static void doStuff()
    {
        //do stuff here
    }
}

から：https : //stackoverflow.com/a/4190969/1676736

あなたが欲しいThread.Join()の方法、またはそのの1 オーバーロードを。

私はあなたのメインスレッドにコールバックメソッドを最初のスレッドに渡し、それが完了すると、メインスレッドのコールバックメソッドが呼び出され、2番目のスレッドを起動できます。これにより、メインスレッドがJoinまたはWaithandleを待機している間にハングするのを防ぎます。メソッドをデリゲートとして渡すことは、とにかくC＃で学ぶのに役立ちます。

これを試して：

List<Thread> myThreads = new List<Thread>();

foreach (Thread curThread in myThreads)
{
    curThread.Start();
}

foreach (Thread curThread in myThreads)
{
    curThread.Join();
}

おそらく他の人を助けるために投稿して、私が思いついたような解決策を探すためにかなりの時間を費やしました。だから私は少し違うアプローチを取った。上記のカウンターオプションがありますが、私は少し異なる方法で適用しました。私は多数のスレッドをスピンオフしていて、スレッドが開始および停止したときにカウンターをインクリメントし、カウンターをデクリメントしました。次に、メインメソッドで一時停止し、スレッドが完了するのを待っていました。

while (threadCounter > 0)
{
    Thread.Sleep(500); //Make it pause for half second so that we don’t spin the cpu out of control.
}

私のブログに記載されています。 http://www.adamthings.com/post/2012/07/11/ensure-threads-have-finished-before-method-continues-in-c/

タスクが完了するのを待っている間にUIが表示を更新できるようにしたい場合は、スレッドでIsAliveをテストするwhileループを使用します。

    Thread t = new Thread(() => someMethod(parameters));
    t.Start();
    while (t.IsAlive)
    {
        Thread.Sleep(500);
        Application.DoEvents();
    }

同じクラス内で、トレッドが終了するのを待つ単純な例を次に示します。また、同じ名前空間内の別のクラスを呼び出します。「using」ステートメントを含めたので、button1を作成する限り、Winformとして実行できます。

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Threading;

namespace ClassCrossCall
{

 public partial class Form1 : Form
 {
  int number = 0; // this is an intentional problem, included for demonstration purposes
  public Form1()
  {
   InitializeComponent();
  }
  private void Form1_Load(object sender, EventArgs e)
  {
   button1.Text="Initialized";
  }
  private void button1_Click(object sender, EventArgs e)
  {
   button1.Text="Clicked";
   button1.Refresh();
   Thread.Sleep(400);
   List<Task> taskList = new List<Task>();
   taskList.Add(Task.Factory.StartNew(() => update_thread(2000)));
   taskList.Add(Task.Factory.StartNew(() => update_thread(4000)));
   Task.WaitAll(taskList.ToArray());
   worker.update_button(this,number);
  }
  public void update_thread(int ms)
  {
   // It's important to check the scope of all variables
   number=ms; // this could be either 2000 or 4000.  Race condition.
   Thread.Sleep(ms);
  }
 }

 class worker
 {
  public static void update_button(Form1 form, int number)
  {
   form.button1.Text=$"{number}";
  }
 }
}