วิธีรอเธรดให้เสร็จสิ้นด้วย. NET

ฉันไม่เคยใช้เธรดมาก่อนใน C # โดยที่ฉันต้องมีสองเธรดรวมถึงเธรด UI หลัก โดยทั่วไปฉันมีดังต่อไปนี้

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. ด้ายเข้าร่วม

เช่นเดียวกับคำตอบของมิทช์ แต่สิ่งนี้จะบล็อกเธรด UI ของคุณอย่างไรก็ตามคุณจะได้รับไทม์เอาต์ในตัวสำหรับคุณ

2. ใช้ WaitHandle

ManualResetEventเป็นWaitHandleเป็น jrista ปัญหา

สิ่งหนึ่งที่ควรทราบคือถ้าคุณต้องการรอหลายเธรด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. ทำแบบอะซิงโครนัสแทน

คำตอบสำหรับคำถามนี้มีคำอธิบายที่ชัดเจนเกี่ยวกับตัวเลือกของคุณด้วยวิธีนี้

มอบหมาย / เหตุการณ์บนเธรดที่ไม่ถูกต้อง

วิธีการจัดกิจกรรม / ผู้รับมอบสิทธิ์จะหมายถึงวิธีการจัดการเหตุการณ์ของคุณอยู่ใน thread1 / thread2 ไม่ใช่เธรด UI หลักดังนั้นคุณจะต้องสลับกลับไปที่ด้านบนสุดของวิธีการ HandleThreadDone:

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

เพิ่ม

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

หลังจากที่คุณเริ่มมัน แต่มันจะไม่สำเร็จเท่าที่ควรเพราะผลลัพธ์เดียวกันกับการวิ่งบนเธรดหลัก!

ฉันขอแนะนำให้อ่านThreadingของ Joe Albahari ใน e-book e-book ฟรีหากคุณต้องการทำความเข้าใจกับการทำเกลียวใน. NET

คำตอบสองข้อก่อนหน้านั้นยอดเยี่ยมมากและสามารถใช้งานได้กับสถานการณ์จำลอง อย่างไรก็ตามมีวิธีอื่นในการซิงโครไนซ์เธรด ต่อไปนี้จะใช้งานได้:

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เป็นหนึ่งในหลาย ๆWaitHandleที่. NET Framework มีให้ พวกเขาสามารถให้ความสามารถในการซิงโครไนซ์เธรดที่สมบูรณ์ยิ่งขึ้นกว่าเครื่องมือที่เรียบง่าย แต่พบบ่อยมากเช่น lock () / Monitor, Thread.Join เป็นต้นนอกจากนี้ยังสามารถใช้ซิงโครไนซ์มากกว่าสองเธรดได้ ที่เชื่อมโยงหลาย ๆ หัวข้อ 'child' หลาย ๆ กระบวนการที่เกิดขึ้นพร้อมกันซึ่งขึ้นอยู่กับหลายขั้นตอนของกันและกันที่จะซิงโครไนซ์ ฯลฯ

หากใช้จาก. 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()วิธีการหรือหนึ่งในoverloads

ฉันจะให้เธรดหลักของคุณส่งเมธอดการเรียกกลับไปยังเธรดแรกของคุณและเมื่อเสร็จแล้วมันจะเรียกเมธอดการเรียกกลับบนเธรดหลักซึ่งสามารถเปิดเธรดที่สองได้ สิ่งนี้จะทำให้เธรดหลักของคุณไม่ถูกแฮงค์ขณะที่รอการเข้าร่วมหรือไวเทิล การส่งเมธอดในฐานะผู้รับมอบสิทธิ์เป็นสิ่งที่มีประโยชน์ในการเรียนรู้ด้วย 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 บนเธรด:

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

นี่คือตัวอย่างง่ายๆที่รอให้ดอกยางเสร็จภายในชั้นเดียวกัน นอกจากนี้ยังทำการเรียกคลาสอื่นในเนมสเปซเดียวกัน ฉันรวมคำสั่ง "using" เพื่อให้สามารถใช้งานเป็น Winform ได้ตราบใดที่คุณสร้าง 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}";
  }
 }
}