在 C# 中使用 AutoResetEvent 控制线程

Question

假设我有一个 class A 和一个 class B 代表任务。我想做一个实验，要开始实验，我需要完成至少 5 个 B 任务和 1 个 A 任务。

我有以下 classes

abstract class Task   
{ 
    public int Id;

    public void Start(object resetEvent)
    {
        EventWaitHandle ewh = (EventWaitHandle)resetEvent;

        Thread.Sleep(new Random(DateTime.Now.Ticks.GetHashCode()).Next(5000, 14000));
        Console.WriteLine("{0} {1} starts",this.GetType().Name, Id);
        ewh.Set();
    }
}

class A : Task
{
    static int ID = 1;
    public A(EventWaitHandle resetEvent)
    {
        Id = ID++;
        new Thread(StartTask).Start(resetEvent);
    }
}

class B : Task
{
    static int ID = 1;
    public B(EventWaitHandle resetEvent)
    {
        Id = ID++;
        new Thread(StartTask).Start(resetEvent);
    }
}

及以下主要内容

static void Main()
{
    A a;

    B[] bs = new B[20];
    int numberOfBs = 0;

    EventWaitHandle aResetEvent = new AutoResetEvent(false);
    EventWaitHandle bResetEvent = new AutoResetEvent(false);

    a = new A(aResetEvent);
    for (int i = 0; i < bs.Length; i++)
        bs[i] = new B(bResetEvent);

    while (numberOfBs < 5)
    {
        bResetEvent.WaitOne();
        numberOfBs++;
    }
    aResetEvent.WaitOne();

    Console.WriteLine("Experiment started with {0} B's!", numberOfBs);
    Thread.Sleep(3000); // check how many B's got in the middle
    Console.WriteLine("Experiment ended with {0} B's!", numberOfBs);
}

现在我有几个problems/questions:

如何才能在可能的 M 个信号中只等待 N 个信号？
我可以只用 1 个 AutoResetEvent 获得我想要的结果吗？
我不明白为什么所有的任务都打印在一起，我希望每个任务完成时打印，现在完成时打印。
下面的代码线程安全吗？

.

while (numberOfBs < 5)
{
    bResetEvent.WaitOne();
    numberOfBs++;
}

会不会是两个线程一起发信号？如果是这样，我可以使用 lock on bResetEvent 来解决这个问题吗？

Answer 1

1.How can I wait for only N signals out of possible M?

就像你在这里做的那样（有点……见#4 的答案）。

2.Can I achieve the result I'm looking for with only 1 AutoResetEvent?

是的。但是在这种情况下您将需要两个计数器（一个用于 A 类型，一个用于 B 类型），并且需要以线程安全的方式访问它们，例如使用 Interlocked class 或使用 lock 语句。所有线程，A 和 B 类型，将共享相同的 AutoResetEvent，但增加它们自己类型的计数器。主线程可以监视每个计数器并在两个计数器都达到所需值后进行处理（A 计数器为 1，B 计数器为 5）。

我建议使用 lock 语句方法，因为它更简单并且可以让您避免完全使用 AutoResetEvent（lock 语句使用 Monitor class，它提供了一些类似于 AutoResetEvent 的功能，同时还提供了确保计数器一致使用所需的同步。

除了你在评论中写的你必须使用 AutoResetEvent（为什么？），所以我猜你坚持使用 Interlocked（没有意义使用 lock 如果你不打算充分利用）。

3.I don't understand why all the tasks are printed together, I expected each task to be printed when it is done and now when everything is done.

因为你有一个错误。您应该创建一个 Random 实例并使用它来确定每个任务的持续时间。您可以在创建每个任务的线程中计算持续时间，或者您可以同步访问（例如使用 lock）并在多个线程中使用相同的 Random 对象。

你不能做的是为每个线程使用相同的种子值创建一个全新的Random对象，因为这样每个线程（或至少大它们的块，取决于时间）最终会得到完全相同的 "random" 数字作为其持续时间。

您会看到所有输出一起出现，因为那是它发生的时候：全部一起。

（是的，如果您快速连续创建多个 Random 对象，它们都将获得相同的种子，无论您是自己明确使用 DateTime.Now，还是让 Random class 这样做。用于种子的滴答计数器没有足够频繁地更新并发运行线程看到不同的值。）

4.is the following code thread safe?

有问题的代码：

while (numberOfBs < 5)
{
    bResetEvent.WaitOne();
    numberOfBs++;
}

…是线程安全的，因为执行该循环的线程与任何其他线程之间共享的唯一数据是 AutoResetEvent 对象，而该对象本身是线程安全的。

也就是通常理解的"thread safe"。我强烈建议您阅读埃里克·利珀特 (Eric Lippert) 的文章 What is this thing you call "thread safe"? 询问某物是否线程安全是一个您可能意识到的复杂得多的问题。

特别是，虽然代码以通常的方式是线程安全的（即数据保持一致），但正如您所注意到的，多个线程可能会在主线程之前到达 Set() 调用可以对第一个做出反应。因此您可能会错过一些通知。

Answer 2

需要任务A和B达到一定变化的任务可以在每次任务完成时通知。当它收到通知时，它可以检查条件是否良好，然后才继续。

输出：

Task 3 still waiting: A0, B0
B reached 1
Task 3 still waiting: A0, B1
A reached 1
Task 3 still waiting: A1, B1
B reached 2
Task 3 still waiting: A1, B2
B reached 3
Task 3 still waiting: A1, B3
A reached 2
Task 3 still waiting: A2, B3
B reached 4
Task 3 still waiting: A2, B4
B reached 5
Task 3 done: A2, B5
A reached 3
B reached 6
B reached 7
B reached 8
B reached 9
B reached 10
All done

节目：

class Program
{
    static int stageOfA = 0;
    static int stageOfB = 0;   
    private static readonly AutoResetEvent _signalStageCompleted = new AutoResetEvent(false);

    static void DoA()
    {
        for (int i = 0; i < 3; i++) {
            Thread.Sleep(100);
            Interlocked.Increment(ref stageOfA);
            Console.WriteLine($"A reached {stageOfA}");
            _signalStageCompleted.Set();
        }
    }

    static void DoB()
    {
        for (int i = 0; i < 10; i++)
        {
            Thread.Sleep(50);
            Interlocked.Increment(ref stageOfB);
            Console.WriteLine($"B reached {stageOfB}");
            _signalStageCompleted.Set();
        }
    }

    static void DoAfterB5andA1()
    {
        while( (stageOfA < 1) || (stageOfB < 5))
        {
            Console.WriteLine($"Task 3 still waiting: A{stageOfA}, B{stageOfB}");
            _signalStageCompleted.WaitOne();
        }
        Console.WriteLine($"Task 3 done: A{stageOfA}, B{stageOfB}");
    }

    static void Main(string[] args)
    {
        Task[] taskArray = { Task.Factory.StartNew(() => DoA()),
                                 Task.Factory.StartNew(() => DoB()),
                                 Task.Factory.StartNew(() => DoAfterB5andA1()) };

        Task.WaitAll(taskArray);
        Console.WriteLine("All done");
        Console.ReadLine();
    }
}

在 C# 中使用 AutoResetEvent 控制线程

Control threads using AutoResetEvent in C#

c#

oop

multithreading

autoresetevent