¿Cómo esperar a que el hilo termine con .NET?

Nunca antes he usado subprocesos en C # donde necesito tener dos subprocesos, así como el subproceso principal de la interfaz de usuario. Básicamente, tengo lo siguiente.

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();
}

Entonces, esencialmente, mi pregunta es cómo hacer que un hilo espere a que termine otro. ¿Cuál es la mejor manera de hacer esto?

Puedo ver 5 opciones disponibles:

1. Hilo. Únete

Como con la respuesta de Mitch. Pero esto bloqueará su hilo de interfaz de usuario, sin embargo, obtendrá un tiempo de espera incorporado para usted.

2. Use un WaitHandle

ManualResetEventes WaitHandlecomo sugirió jrista.

Una cosa a tener en cuenta es que si desea esperar varios subprocesos, WaitHandle.WaitAll()no funcionará de forma predeterminada, ya que necesita un subproceso MTA. Puede evitar esto marcando su Main()método con MTAThread, sin embargo, esto bloquea su mensaje y no es recomendable por lo que he leído.

3. Dispara un evento

Vea esta página de Jon Skeet sobre eventos y subprocesos múltiples, es posible que un evento pueda quedar sin suscripción entre el ify el EventName(this,EventArgs.Empty)- me ha sucedido antes.

(Ojalá estas compilación, no lo he probado)

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. Use un delegado

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();
        }
    }
}

Si usa el método _count, podría ser una idea (para estar seguro) incrementarlo usando

Interlocked.Increment(ref _count)

Me interesaría saber la diferencia entre usar delegados y eventos para la notificación de subprocesos, la única diferencia que sé es que los eventos se llaman sincrónicamente.

5. Hazlo asincrónicamente

La respuesta a esta pregunta tiene una descripción muy clara de sus opciones con este método.

Delegado / Eventos en el hilo equivocado

La forma de hacer eventos / delegar significará que su método de controlador de eventos está en thread1 / thread2 no en el hilo principal de la interfaz de usuario , por lo que deberá volver a la derecha en la parte superior de los métodos HandleThreadDone:

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

Añadir

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

después de iniciarlo, ¡pero eso no logrará mucho, ya que es esencialmente el mismo resultado que ejecutar en el hilo principal!

Puedo recomendar leer el libro electrónico gratuito Threading in C # de Joe Albahari , si desea obtener una comprensión de los hilos en .NET.

Las dos respuestas anteriores son geniales y funcionarán para escenarios simples. Sin embargo, hay otras formas de sincronizar hilos. Lo siguiente también funcionará:

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 es uno de los diversos WaitHandle que ofrece .NET Framework. Pueden proporcionar capacidades de sincronización de subprocesos mucho más ricas que las herramientas simples pero muy comunes como lock () / Monitor, Thread.Join, etc. También se pueden usar para sincronizar más de dos subprocesos, lo que permite escenarios complejos como un subproceso 'maestro' que coordina múltiples subprocesos 'secundarios', múltiples procesos concurrentes que dependen de varias etapas entre sí para sincronizarse, etc.

Si utiliza desde .NET 4, este ejemplo puede ayudarlo a:

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
    }
}

de: https://stackoverflow.com/a/4190969/1676736

Desea el Thread.Join()método, o una de sus sobrecargas .

Quisiera que su hilo principal pase un método de devolución de llamada a su primer hilo, y cuando termine, invocará el método de devolución de llamada en el hilo principal, que puede iniciar el segundo hilo. Esto evita que su hilo principal se cuelgue mientras espera un Join o Waithandle. Pasar métodos como delegados es algo útil para aprender con C # de todos modos.

Prueba esto:

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

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

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

Posiblemente para ayudar a otros, pasé bastante tiempo buscando una solución como la que se me ocurrió. Entonces tomé un enfoque un poco diferente. Hay una opción de contador arriba, solo la apliqué un poco diferente. Estaba hilando numerosos hilos e incrementé un contador y disminuí un contador cuando un hilo comenzó y se detuvo. Luego, en el método principal, quería pausar y esperar a que se completaran los hilos que hice.

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

Documentado en mi blog. http://www.adamthings.com/post/2012/07/11/ensure-threads-have-finished-before-method-continues-in-c/

Cuando quiero que la IU pueda actualizar su pantalla mientras espero que se complete una tarea, uso un ciclo while que prueba IsAlive en el hilo:

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

Aquí hay un ejemplo simple que espera a que termine una banda de rodadura, dentro de la misma clase. También realiza una llamada a otra clase en el mismo espacio de nombres. Incluí las declaraciones de "uso" para que pueda ejecutarse como Winform siempre que cree el botón1.

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}";
  }
 }
}