Come attendere il completamento del thread con .NET?

Non ho mai usato il threading prima in C # dove ho bisogno di avere due thread, così come il thread dell'interfaccia utente principale. Fondamentalmente, ho il seguente.

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

Quindi, in sostanza, la mia domanda è come avere un thread in attesa che ne finisca un altro. Qual è il modo migliore per farlo?

Posso vedere 5 opzioni disponibili:

1. Thread.Join

Come con la risposta di Mitch. Ma questo bloccherà il tuo thread dell'interfaccia utente, tuttavia ottieni un Timeout integrato per te.

2. Utilizzare a WaitHandle

ManualResetEventè un WaitHandlejrista come suggerito.

Una cosa da notare è se vuoi aspettare più thread, WaitHandle.WaitAll()non funzionerà di default, poiché ha bisogno di un thread MTA. Puoi aggirare questo contrassegnando il tuo Main()metodo con MTAThread- tuttavia questo blocca il tuo pump dei messaggi e non è raccomandato da quello che ho letto.

3. Attiva un evento

Vedi questa pagina di Jon Skeet su eventi e multi-threading, è possibile che un evento possa essere cancellato tra il ife il EventName(this,EventArgs.Empty)- è successo a me prima.

(Spero che questi compilano, non ho provato)

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. Utilizzare un delegato

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

Se si utilizza il metodo _count, potrebbe essere un'idea (per sicurezza) incrementarlo utilizzando

Interlocked.Increment(ref _count)

Sarei interessato a conoscere la differenza tra l'utilizzo di delegati ed eventi per la notifica di thread, l'unica differenza che conosco sono gli eventi chiamati in modo sincrono.

5. Fallo invece in modo asincrono

La risposta a questa domanda ha una descrizione molto chiara delle tue opzioni con questo metodo.

Delegato / Eventi sul thread errato

Il modo evento / delegato di fare le cose significherà che il tuo metodo del gestore eventi è su thread1 / thread2 non sul thread dell'interfaccia utente principale , quindi dovrai tornare indietro nella parte superiore dei metodi HandleThreadDone:

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

Inserisci

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

dopo averlo avviato, ma questo non compirà molto in quanto è essenzialmente lo stesso risultato della corsa sul thread principale!

Consiglio vivamente di leggere il threading di Joe Albahari nell'e-book gratuito di C # , se vuoi avere una comprensione del threading in .NET.

Le due risposte precedenti sono fantastiche e funzioneranno per scenari semplici. Esistono altri modi per sincronizzare i thread, tuttavia. Funzionerà anche:

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 è uno dei vari WaitHandle che .NET Framework ha da offrire. Possono fornire funzionalità di sincronizzazione dei thread molto più ricche rispetto agli strumenti semplici ma molto comuni come lock () / Monitor, Thread.Join, ecc. Possono anche essere utilizzati per sincronizzare più di due thread, consentendo scenari complessi come un thread "master" che coordina più thread "figlio", più processi simultanei che dipendono da più fasi l'uno dall'altro per la sincronizzazione, ecc.

Se si utilizza da .NET 4 questo esempio può aiutarti:

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

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

Vuoi il Thread.Join()metodo o uno dei suoi sovraccarichi .

Vorrei che il tuo thread principale passasse un metodo di callback al tuo primo thread e, al termine, invocherà il metodo di callback sul mainthread, che può avviare il secondo thread. Ciò evita che il thread principale si blocchi mentre è in attesa di Join o Waithandle. Passare metodi come delegati è comunque utile imparare con C #.

Prova questo:

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

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

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

Pubblicare messaggi per aiutare alcuni altri, ha trascorso un bel po 'di tempo a cercare una soluzione come quella che mi è venuta in mente. Quindi ho adottato un approccio leggermente diverso. C'è un'opzione contatore sopra, l'ho appena applicata in modo leggermente diverso. Stavo filando numerosi thread, incrementando un contatore e decrementando un contatore all'avvio e all'arresto di un thread. Quindi, nel metodo principale, volevo mettere in pausa e attendere il completamento dei thread.

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

Documentato sul mio blog. http://www.adamthings.com/post/2012/07/11/ensure-threads-have-finished-before-method-continues-in-c/

Quando voglio che l'interfaccia utente sia in grado di aggiornare il suo display mentre aspetto che un'attività venga completata, uso un ciclo while che testa IsAlive sul thread:

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

Ecco un semplice esempio che attende che un battistrada finisca, all'interno della stessa classe. Inoltre effettua una chiamata a un'altra classe nello stesso spazio dei nomi. Ho incluso le istruzioni "using" in modo che possa essere eseguito come Winform fino a quando si crea button1.

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