线程系列09,线程的等待、通知,以及手动控制线程数量

阳光穿透心脏的1/2处 2021-10-19 16:12 319阅读 0赞

当一个线程直到收到另一个线程的通知才执行相关的动作，这时候，就可以考虑使用"事件等待句柄(Event Wait Handles)"。使用"事件等待句柄"主要用到3个类： AutoResetEvent, ManualResetEvent以及CountdownEvent(.NET 4.0以后才有)。本篇包括：

※ 一个线程等待另一个线程的通知  
※ 2个线程互相通知等待  
※ 一个线程等待队列中的多个任务通知  
※ 手动控制线程的数量

□ 一个线程等待另一个线程的通知

最简单的情景是：发出信号的线程只发出一次通知，等待的线程收到通知也只做一次事情。等待的线程肯定有一个等待方法，发出信号的线程必须有一个发出信号的方法，AutoResetEvent类提供了相关方法。

class Program

{

//true表示将初始状态设置为终止状态

static EventWaitHandle _wait = new AutoResetEvent(false);

static void Main(string[] args)

{

new Thread(Waiter).Start();

Thread.Sleep(1000);

_wait.Set();//发出指示

}

static void Waiter()

{

Console.WriteLine("一切准备就绪，等待指示！");

_wait.WaitOne();

Console.WriteLine("收到指示~~");

}

[![42][]][42 1]

○ AutoResetEvent就像地铁入口的十字转门，有票插入，就让进，而且每次只让一个人进。  
○ 当调用WaitOne方法，表示该线程已被阻塞，正在等待信号，就像十字转门旁等待进入的乘客。  
○ 当调用Set方法，表示发出信号给等待线程，就像十字转门收到车票，乘客可以通过。

关于AutoResetEvent:  
○ 还可通过这种方式创建AutoResetEvent实例：var auto = new EventWaitHandle(false, EventResetMode.AutoReset);  
○ 如果调用了Set方法，却没有其它线程调用WaitOne方法，这个handle会一直存在  
○ 如果调用Set方法多次，却有多个线程调用WaitOne方法，也只能让这些线程挨个接收信号，即每次只有一个线程接收信号  
○ WaitOne还有几个接收时间间隔参数的重载方法，使用WaitOne(0)可以测试一个wait handle是否已经打开  
○ GC自动回收wait handles

□ 2个线程互相通知等待

还有一种情形：发出信号的线程要发出多次通知，每一次需要确认等待线程收到后再发下一个通知。大概的过程就是：线程A第一次做事并发出通知，进入等待状态；线程B收到通知，发出通知，通知线程A，线程B进入等待状态；线程A收到线程B的通知，第二次做事并发出通知，进入等待状态......2个线程互相通知，每个线程既是发出信号者，也是等待者。借助AutoResetEvent类可以解决此需求。

class Program

{

static EventWaitHandle _ready = new AutoResetEvent(false);

static EventWaitHandle _go = new AutoResetEvent(false);

static readonly object o = new object();

private static string _msg;

static void Main(string[] args)

{

new Thread(DoSth).Start();

//第一次等待直到另外一个线程准备好

_ready.WaitOne();

lock (o)

{

_msg = "你好";

}

_go.Set();

//第二次等待

_ready.WaitOne();

lock (o)

{

_msg = "吗";

}

_go.Set();

//第三次

_ready.WaitOne();

lock (o)

{

_msg = null;

}

_go.Set();

}

static void DoSth()

{

while (true)

{

_ready.Set();

_go.WaitOne();

lock (o)

{

if(_msg == null) return;

Console.WriteLine(_msg);

}

[![43][]][43 1]

把Main方法中的线程称为主线程，把另一个线程称为工作线程，2个线程是这样工作的：

→主线程使用WaitOne方法第一次等待，说：“工作线程，我等在这里”

→工作线程使用Set方法，说：“主线程，我给你信号，你准备第一条信息吧”，并且又使用WaitOne方法让自己等待，就说：“主线程，我给你信号了，我等在这里，准备接收你的第一条信息”，再看看暂时还没有需要显示的信息，于是作罢

→主线程收到工作线程的信号，设置第一条信息，然后使用Set方法，说"工作线程，我的第一条信息给你，给你信号"，并且又使用WaitOne方法让自己第二次等待，说："工作线程，我给你信号了，我等在这里"

→工作线程又使用Set方法，说：“主线程，我给你信号，你去准备第二条信息吧”，并且又使用WaitOne方法让自己等待，就说：“主线程，我已经给你信号了，我等在这里，准备接收你的第二条信息”，再看看这时有需要显示的信息，就把信息打印了出来

→依次类推

□ 一个线程等待队列中的多个任务通知

当一个等待的线程，需要逐个执行多个任务，就可以把任务放在队列中。

通常把能实现实现上述需求的叫做"生产/消费队列"。所谓的"生产"是指能把多个任务放到队列中，所谓"消费"是指当任务逐一出列，再执行该任务。

class ProducerConsumerQueue : IDisposable

{

EventWaitHandle _ewh = new AutoResetEvent(false);

private Thread _worker; //等待线程

private readonly object _locker = new object();

Queue<string> _tasks = new Queue<string>();//任务队列

public ProducerConsumerQueue()

{

_worker = new Thread(Work);

_worker.Start();

}

//任务进入队列

public void EnqueueTask(string task)

{

lock (_locker)

{

_tasks.Enqueue(task);

}

//任务一旦进入队列就发出信号

_ewh.Set();

}

void Work()

{

while (true)

{

//从队列中获取task

string task = null;

lock (_locker)

{

if (_tasks.Count > 0)

{

task = _tasks.Dequeue();

if(task == null) return;

}

//如果task不为null，模拟执行task

if (task != null)

{

Console.WriteLine("正在执行线程任务 " + task);

Thread.Sleep(1000); //模拟线程执行的过程

}

else//如果taks为null

{

_ewh.WaitOne();//等待信号

}

public void Dispose()

{

EnqueueTask(null); //发出信号让消费线程退出

_worker.Join();//让消费线程借宿

_ewh.Close();//释放event wait handle

}

○ EnqueueTask方法，让任务进入队列，每个进入队列的任务使用Set方法发出通知，产生任务的过程就是所谓的"生产"  
○ Wokr方法，在没有task的时候，使用WaitOne方法一直等待；当任务出列，就执行任务，执行任务的过程就是所谓的"消费"  
○ 构造函数创建、启动等待线程，让等待线程一直工作者(通过无限循环)

客户端调用。

class Program

{

static void Main(string[] args)

{

using (ProducerConsumerQueue q = new ProducerConsumerQueue())

{

q.EnqueueTask("hello");

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

{

q.EnqueueTask("报数" + i);

}

q.EnqueueTask("world");

}

[![44][]][44 1]

□ 手动控制线程的数量

■ 使用ManualResetEvent

如果把AutoResetEvent比作地铁入口的十字转门，一次只能允许一个人进入；ManualResetEvent可看作公司门卫，上班时间到，打开门可以让多人进入。ManualResetEvent的Set方法就如同开门，任意多个线程可以进入，Reset方法如同关门，线程从此不能再进入。

创建ManualResetEvent实例有2种方式：

var manual1 = new ManualResetEvent (false);

var manual2 = new EventWaitHandle (false, EventResetMode.ManualReset);

以下是EventWaitHandle的一个简单应用：

class Program

{

static EventWaitHandle handle = new ManualResetEvent(false);

static void Main(string[] args)

{

handle.Set();

new Thread(SaySth).Start("Hello");

new Thread(SaySth).Start("World");

Thread.Sleep(2000);

handle.Reset();

new Thread(SaySth).Start("Again");

}

static void SaySth(object data)

{

handle.WaitOne();

Console.WriteLine("我想说的是：" + data);

}

[![45][]][45 1]

○ Set方法，相当于开门，其后面的2个线程有效  
○ Reset方法，相当于关门，其后面的1个线程无效

■ 使用CountdownEvent

CountdownEvent也可以看作公司门卫，只不过，上班时间到，规定只允许若干个人进去。

class Program

{

static CountdownEvent _countdown = new CountdownEvent(2);

static void Main(string[] args)

{

new Thread(SaySth).Start("1");

new Thread(SaySth).Start("2");

}

static void SaySth(object o)

{

Thread.Sleep(1000);

Console.WriteLine(o);

_countdown.Signal();

}

[![46][]][46 1]

○ 在CountdownEvent的构造函数中设置允许的最大线程数  
○ Signal方法表示计数一次

>   
> 总结：
> 
> ○ 使用AutoResetEvent类，可以让一个线程等待另一个线程的通知，2个线程互相通知等待，一个线程等待队列中的多个任务通知  
> ○ 使用ManualResetEvent类，手动控制任意多的线程数量  
> ○ CountdownEvent类，手动控制固定数量的线程数量

**线程系列包括：**

### [线程系列01,前台线程,后台线程,线程同步][01] ###

### [线程系列02,多个线程同时处理一个耗时较长的任务以节省时间][02] ###

### [线程系列03,多线程共享数据,多线程不共享数据][03] ###

### [线程系列04,传递数据给线程,线程命名,线程异常处理,线程池][04] ###

### [线程系列05,手动结束线程][05] ###

### [线程系列06,通过CLR代码查看线程池及其线程][06_CLR] ###

### [线程系列07,使用lock语句块或Interlocked类型方法保证自增变量的数据同步][07_lock_Interlocked] ###

### [线程系列08,实现线程锁的各种方式,使用lock,Montor,Mutex,Semaphore以及线程死锁][08_lock_Montor_Mutex_Semaphore] ###

[线程系列09,线程的等待、通知,以及手动控制线程数量][09]

### [线程系列10,无需显式调用线程的情形][10] ###

转载于:https://www.cnblogs.com/darrenji/p/3991156.html

[42]: /images/20211019/7742b9e867d24ba09d7e3ac446d7f0d8.png
[42 1]: https://images0.cnblogs.com/blog/417212/201409/241711422015775.png
[43]: /images/20211019/db90f5aa105e4880815e788429eda906.png
[43 1]: https://images0.cnblogs.com/blog/417212/201409/241711441073390.png
[44]: /images/20211019/b061bc7fe4f44492bf0c27033b0ddb17.png
[44 1]: https://images0.cnblogs.com/blog/417212/201409/241711455764106.png
[45]: /images/20211019/ac296c0f7d2f40ef856628bae15f770d.png
[45 1]: https://images0.cnblogs.com/blog/417212/201409/241711475603978.png
[46]: /images/20211019/777d3d55c69842d4bd14c2376b95bd30.png
[46 1]: https://images0.cnblogs.com/blog/417212/201409/241711510291338.png
[01]: http://www.cnblogs.com/darrenji/p/3979641.html
[02]: http://www.cnblogs.com/darrenji/p/3980252.html
[03]: http://www.cnblogs.com/darrenji/p/3981679.html
[04]: http://www.cnblogs.com/darrenji/p/3984215.html
[05]: http://www.cnblogs.com/darrenji/p/3984277.html
[06_CLR]: http://www.cnblogs.com/darrenji/p/3986231.html
[07_lock_Interlocked]: http://www.cnblogs.com/darrenji/p/3988223.html
[08_lock_Montor_Mutex_Semaphore]: http://www.cnblogs.com/darrenji/p/3989552.html
[09]: http://www.cnblogs.com/darrenji/p/3991156.html
[10]: http://www.cnblogs.com/darrenji/p/3993016.html