C# 应用 - 多线程 6) 处理同步数据之手动同步 AutoResetEvent 和 ManualResetEvent

1. 类的关系

AutoResetEvent 和 ManualResetEvent 都继承自 System.Threading.EventWaitHandle 类(EventWaitHandle 继承自 WaitHandle)；
用于线程交互 (或线程信号)

2. 常用方法

2.1 WaitHandle 几个常用的方法

public virtual bool WaitOne(int millisecondsTimeout); //阻止当前线程，直到当前 System.Threading.WaitHandle 收到信号，或直到 millisecondsTimeout 后。
public virtual bool WaitOne(); //阻止当前线程，直到当前 System.Threading.WaitHandle 收到信号。
public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout);
public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout);

2.2 EventWaitHandle 几个常用的方法

public bool Set();

将事件设置为有信号，从而允许一个或多个等待线程继续执行
public bool Reset();

将事件设置为非终止状态，从而导致线程受阻

2.3 AutoResetEvent

该类的定义：通知正在等待的线程已发生事件
public AutoResetEvent(bool initialState); //initialState 指是否将初始状态设置为终止状态的类

2.4 ManualResetEvent

该类的定义：通知一个或多个正在等待的线程已发生事件
public ManualResetEvent(bool initialState);

3. 使用逻辑

3.1 AutoResetEvent 的使用逻辑

实例化 AutoResetEvent 时，需要设置初始状态是否为终止状态；
若遇到状态为非终止状态的 AutoResetEvent 的 Wait 系列方法(如 WaitOne())，将阻止当前线程继续往下执行，直到当前 AutoResetEvent 收到信号；
收到信号后，保持终止状态并释放一个等待线程，让其继续往下执行，然后自动返回非终止状态。

3.2 ManualResetEvent 的使用逻辑

实例化 ManualResetEvent 时，需要设置初始状态是否为终止状态；
若遇到状态为非终止状态的 ManualResetEvent 的 Wait 系列方法(如 WaitOne())，将阻止当前线程继续往下执行，直到当前 ManualResetEvent 收到信号；
收到信号后，所有等待线程都被释放，可以继续往下执行；
跟 AutoResetEvent 不同的是，收到信号后，ManualResetEvent 将继续保持信号，直到通过手动调用 Reset() 方法重置 ManualResetEvent 的状态为非终止。

4. 例子

4.1 AutoResetEvent

using System;

using System.Threading;

class Example

{

    private static AutoResetEvent event_1 = new AutoResetEvent(true);

    private static AutoResetEvent event_2 = new AutoResetEvent(false);

    static void Main()

    {

        for (int i = 1; i < 4; i++)

        {

            Thread t = new Thread(ThreadProc);

            t.Name = "Thread_" + i;

            t.Start();

        }

        Thread.Sleep(250);

        for (int i = 0; i < 2; i++)

        {

            Console.WriteLine("按任意键释放另一个线程");

            Console.ReadLine();

            event_1.Set();

            Thread.Sleep(250);

        }

        Console.WriteLine("\r\n至此所有线程都在等待 AutoResetEvent #2.");

        for (int i = 0; i < 3; i++)

        {

            Console.WriteLine("按任意键释放另一个线程");

            Console.ReadLine();

            event_2.Set();

            Thread.Sleep(250);

        }

    }

    static void ThreadProc()

    {

        string name = Thread.CurrentThread.Name;

        Console.WriteLine("{0} 等待 AutoResetEvent #1.", name);

        event_1.WaitOne();

        Console.WriteLine("{0} 被 AutoResetEvent #1 释放.", name);

        Console.WriteLine("{0} 等待 AutoResetEvent #2.", name);

        event_2.WaitOne();

        Console.WriteLine("{0} 被 from AutoResetEvent #2 释放.", name);

        Console.WriteLine("{0} 结束.", name);

    }

}

/* 上面例子将输出如下:

Thread_1 等待 AutoResetEvent #1.

Thread_1 被 AutoResetEvent #1 释放.

Thread_1 等待 AutoResetEvent #2.

Thread_2 等待 AutoResetEvent #1.

Thread_3 等待 AutoResetEvent #1.

按任意键释放另一个线程

Thread_2 被 AutoResetEvent #1 释放.

Thread_2 等待 AutoResetEvent #2.

按任意键释放另一个线程

Thread_3 被 AutoResetEvent #1 释放.

Thread_3 等待 AutoResetEvent #2.

至此所有线程都在等待 AutoResetEvent #2.

按任意键释放另一个线程.

Thread_1 被 from AutoResetEvent #2 释放.

Thread_1 结束.

按任意键释放另一个线程.

Thread_2 被 from AutoResetEvent #2 释放.

Thread_2 结束.

按任意键释放另一个线程.

Thread_3 被 from AutoResetEvent #2 释放.

Thread_3 结束.

 */

4.2 ManualResetEvent

using System;

using System.Threading;

public class Example

{

    private static ManualResetEvent mre = new ManualResetEvent(false);

    static void Main()

    {

        Console.WriteLine("\n开启 3 个被 ManualResetEvent 阻塞的线程\n");

        for (int i = 0; i <= 2; i++)

        {

            Thread t = new Thread(ThreadProc);

            t.Name = "Thread_" + i;

            t.Start();

        }

        Thread.Sleep(500);

        Console.WriteLine("\n所有线程已开启，请按下 enter 键发送信号从而一次性释放所有线程\n");

        Console.ReadLine();

        mre.Set();

        Thread.Sleep(500); // 主线程等待 500 毫秒让子线程先执行完毕

        Console.WriteLine("\n当 ManualResetEvent 是有信号时，即使遇到 WaitOne() 也不会被阻塞：\n");

        for (int i = 3; i <= 4; i++)

        {

            Thread t = new Thread(ThreadProc);

            t.Name = "Thread_" + i;

            t.Start();

        }

        Thread.Sleep(500);

        Console.WriteLine("\n请按下 enter 键盘触发 Reset() 方法, 从而后面的线程在遇到 WaitOne() 时继续被阻塞.\n");

        Console.ReadLine();

        mre.Reset();

        Thread t5 = new Thread(ThreadProc);

        t5.Name = "Thread_5";

        t5.Start();

        Thread.Sleep(500);

        Console.WriteLine("\n请按下 enter 键发送信号.");

        Console.ReadLine();

        mre.Set();

        Console.ReadLine();

    }

    private static void ThreadProc()

    {

        string name = Thread.CurrentThread.Name;

        Console.WriteLine(name + " starts and calls mre.WaitOne()");

        mre.WaitOne();

        Console.WriteLine(name + " ends.");

    }

}

/* 上面例子将输出如下:

开启 3 个被 ManualResetEvent 阻塞的线程

Thread_0 starts and calls mre.WaitOne()

Thread_1 starts and calls mre.WaitOne()

Thread_2 starts and calls mre.WaitOne()

所有线程已开启，请按下 enter 键发送信号从而一次性释放所有线程

Thread_0 ends.

Thread_1 ends.

Thread_2 ends.

当 ManualResetEvent 是有信号时，即使遇到 WaitOne() 也不会被阻塞：

Thread_3 starts and calls mre.WaitOne()

Thread_3 ends.

Thread_4 starts and calls mre.WaitOne()

Thread_4 ends.

请按下 enter 键盘触发 Reset() 方法, 从而后面的线程在遇到 WaitOne() 时继续被阻塞.

Thread_5 starts and calls mre.WaitOne()

请按下 enter 键发送信号.

Thread_5 ends.

 */

巴特西

C# 应用 - 多线程 6) 处理同步数据之手动同步 AutoResetEvent 和 ManualResetEvent

1. 类的关系

2. 常用方法

2.1 WaitHandle 几个常用的方法

2.2 EventWaitHandle 几个常用的方法

2.3 AutoResetEvent

2.4 ManualResetEvent

3. 使用逻辑

3.1 AutoResetEvent 的使用逻辑

3.2 ManualResetEvent 的使用逻辑

4. 例子

4.1 AutoResetEvent

4.2 ManualResetEvent

最新文章

热门文章