Wie kann ich warten, bis der Thread mit .NET beendet ist?

Ich habe noch nie zuvor Threading in C # verwendet, wo ich zwei Threads sowie den Haupt-UI-Thread haben muss. Grundsätzlich habe ich folgendes.

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

Meine Frage ist also im Wesentlichen, wie man einen Thread warten lässt, bis ein anderer fertig ist. Was ist der beste Weg, dies zu tun?

Ich kann 5 verfügbare Optionen sehen:

1. Thread.Join

Wie bei Mitch's Antwort. Dies blockiert jedoch Ihren UI-Thread, Sie erhalten jedoch ein Timeout, das für Sie integriert ist.

2. Verwenden Sie a WaitHandle

ManualResetEventist ein WaitHandlewie jrista vorgeschlagen.

Wenn Sie auf mehrere Threads warten möchten, WaitHandle.WaitAll()funktioniert dies standardmäßig nicht, da ein MTA-Thread erforderlich ist. Sie können dies umgehen, indem Sie Ihre Main()Methode mit markieren. MTAThreadDies blockiert jedoch Ihre Nachrichtenpumpe und wird nach dem, was ich gelesen habe, nicht empfohlen.

3. Feuern Sie ein Ereignis ab

Auf dieser Seite von Jon Skeet finden Sie Informationen zu Ereignissen und Multithreading. Es ist möglich, dass ein Ereignis zwischen dem ifund dem nicht mehr abonniert wirdEventName(this,EventArgs.Empty) - es ist mir schon einmal passiert.

(Hoffentlich kompilieren diese, ich habe es nicht versucht)

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. Verwenden Sie einen Delegaten

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

Wenn Sie die Methode _count verwenden, ist es möglicherweise (aus Sicherheitsgründen) eine Idee, sie mit zu erhöhen

Interlocked.Increment(ref _count)

Mich würde interessieren, welchen Unterschied es zwischen der Verwendung von Delegaten und Ereignissen für die Thread-Benachrichtigung gibt. Der einzige Unterschied, den ich kenne, besteht darin, dass Ereignisse synchron aufgerufen werden.

5. Tun Sie es stattdessen asynchron

Die Antwort auf diese Frage enthält eine sehr klare Beschreibung Ihrer Optionen mit dieser Methode.

Delegate / Events im falschen Thread

Die Veranstaltung / Delegierten Art , die Dinge werden Ihre Event - Handler bedeuten Methode ist auf thread1 / thread2 nicht die Haupt - UI - Thread , so müssen Sie direkt an der Spitze der HandleThreadDone Methoden zurückschalten:

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

Hinzufügen

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

nachdem Sie es gestartet haben, aber das wird nicht viel bewirken, da es im Wesentlichen das gleiche Ergebnis ist wie das Ausführen auf dem Haupt-Thread!

Ich kann Joe Albaharis Threading in C # -freiem E-Book nur empfehlen , wenn Sie sich mit Threading in .NET vertraut machen möchten.

Die beiden vorherigen Antworten sind großartig und funktionieren für einfache Szenarien. Es gibt jedoch auch andere Möglichkeiten, Threads zu synchronisieren. Folgendes wird auch funktionieren:

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 ist eines der verschiedenen WaitHandles , die das .NET Framework bietet. Sie bieten viel umfangreichere Funktionen zur Thread-Synchronisierung als die einfachen, aber sehr verbreiteten Tools wie lock () / Monitor, Thread.Join usw. Sie können auch zum Synchronisieren von mehr als zwei Threads verwendet werden, wodurch komplexe Szenarien wie ein 'Master'-Thread ermöglicht werden das koordiniert mehrere "untergeordnete" Threads, mehrere gleichzeitige Prozesse, die von mehreren zu synchronisierenden Stufen voneinander abhängig sind, usw.

Bei Verwendung von .NET 4 kann dieses Beispiel Ihnen helfen:

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

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

Sie möchten die Thread.Join()Methode oder eine ihrer Überladungen .

Ich würde Ihren Hauptthread eine Rückrufmethode an Ihren ersten Thread übergeben lassen, und wenn dies erledigt ist, wird die Rückrufmethode auf dem Hauptthread aufgerufen, die den zweiten Thread starten kann. Dies verhindert, dass Ihr Hauptfaden hängt, während er auf einen Join oder Waithandle wartet. Das Übergeben von Methoden als Delegaten ist ohnehin eine nützliche Sache, um mit C # zu lernen.

Versuche dies:

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

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

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

Das Posten, um vielleicht anderen zu helfen, hat ziemlich viel Zeit damit verbracht, nach einer Lösung zu suchen, wie ich sie mir ausgedacht habe. Also habe ich einen etwas anderen Ansatz gewählt. Es gibt oben eine Zähleroption, ich habe sie nur etwas anders angewendet. Ich drehte zahlreiche Threads ab und erhöhte einen Zähler und dekrementierte einen Zähler, als ein Thread gestartet und gestoppt wurde. Dann wollte ich in der Hauptmethode pausieren und warten, bis die Threads abgeschlossen sind.

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

In meinem Blog dokumentiert. http://www.adamthings.com/post/2012/07/11/ensure-threads-have-finished-before-method-continues-in-c/

Wenn ich möchte, dass die Benutzeroberfläche ihre Anzeige aktualisieren kann, während sie auf den Abschluss einer Aufgabe wartet, verwende ich eine while-Schleife, die IsAlive für den Thread testet:

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

Hier ist ein einfaches Beispiel, das darauf wartet, dass ein Profil innerhalb derselben Klasse fertig ist. Es ruft auch eine andere Klasse im selben Namespace auf. Ich habe die "using" -Anweisungen eingefügt, damit sie als Winform ausgeführt werden können, solange Sie button1 erstellen.

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