Jak mogę czekać na zakończenie wątku with.NET?

Dodaj

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

Po uruchomieniu go, ale to nie przyniesie wiele, ponieważ jest to zasadniczo taki sam wynik jak uruchomienie na głównym wątku!

Poprzednie dwie odpowiedzi są świetne i sprawdzą się w prostych scenariuszach. Istnieją jednak inne sposoby synchronizacji wątków. Będą również działać:

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 jest jednym z różnych WaitHandle ' S, że. NET framework ma do zaoferowania. Mogą one zapewnić znacznie bogatsze możliwości synchronizacji wątków niż proste, ale bardzo popularne narzędzia, takie jak lock () / Monitor, Thread.Dołącz, itp.

Mogą być również używane do synchronizacji więcej niż dwóch threads, umożliwiając złożone scenariusze, takie jak wątek "master", który koordynuje wiele wątków "potomnych", wiele równoległych procesów, które są zależne od kilku etapów siebie do synchronizacji, itp.

Jeśli używasz Z. NET 4 ta próbka może Ci pomóc:

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

Od: Utwórz wiele wątków i poczekaj na ich zakończenie

Chcesz Thread.Join() Metoda, lub jedno z jej przeciążeń .

Chciałbym, aby twój główny wątek przekazał metodę callback do pierwszego wątku, a kiedy to się skończy, wywoła metodę callback na wątku głównym, który może uruchomić drugi wątek. Dzięki temu główny wątek nie zawiesi się podczas oczekiwania na połączenie lub czekanie. Przekazywanie metod jako delegatów jest przydatną rzeczą do nauki w C# i tak.

Spróbuj tego:

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

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

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

Kiedy chcę, aby interfejs użytkownika był w stanie zaktualizować swój wyświetlacz czekając na ukończenie zadania, używam pętli while, która testuje IsAlive w wątku:

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

Przyjęłam nieco inne podejście. W poprzednich odpowiedziach jest opcja licznika i zastosowałem ją nieco inaczej. Obracałem wiele wątków i zwiększałem licznik i zmniejszałem licznik, gdy wątek zaczynał się i zatrzymywał. Następnie w głównej metodzie chciałem pauzować i czekać na zakończenie wątków zrobiłem.

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

Jest to udokumentowane w moim wpisie na blogu: http://www.adamthings.com/post/2012/07/11/ensure-threads-have-finished-before-method-continues-in-c/

Oto prosty przykład, który czeka na zakończenie bieżnika w tej samej klasie. Wykonuje również wywołanie innej klasy w tej samej przestrzeni nazw. Dodałem instrukcje "using", aby można było wykonać jako Formularz Windows Forms tak długo, jak utworzysz 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}";
        }
    }
}