个人中心
gpt4 book ai didi

详细解析C#多线程同步事件及等待句柄

转载 作者：qq735679552 更新时间：2022-09-27 22:32:09 30 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章详细解析C#多线程同步事件及等待句柄由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

最近捣鼓了一下多线程的同步问题，发现其实C#关于多线程同步事件处理还是很灵活，这里主要写一下，自己测试的一些代码，涉及到了AutoResetEvent 和 ManualResetEvent，当然还有也简要提了一下System.Threading.WaitHandle.WaitOne 、System.Threading.WaitHandle.WaitAny和System.Threading.WaitHandle.WaitAll ，下面我们一最初学者的角度来看，多线程之间的同步.

假设有这样的一个场景，主线程开了一个子线程，让子线程等着，等主线程完成了某件事情时再通知子线程去往下执行，这里关键就在于这个怎让子线程等着，主线程怎通知子线程，一般情况下我们不难想到用一个公共变量，于是咱们就有了下面的代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
 
namespace AutoResetEventTest
{
   class Class1
   {
     static bool flag = true ;
 
     static void DoWork()
     {
       Console.WriteLine( "  worker thread started, now waiting on event..." );
       while (flag)
       {
 
       }
       Console.WriteLine( "  worker thread reactivated, now exiting..." );
     }
 
     static void Main()
     {
       Console.WriteLine( "main thread starting worker thread..." );
       Thread t = new Thread(DoWork);
       t.Start();
 
       Console.WriteLine( "main thrad sleeping for 1 second..." );
       Thread.Sleep(1000);
 
       Console.WriteLine( "main thread signaling worker thread..." );
       flag = false ;
     }
   }
}

虽然目的达到了，但是看着这代码就纠结，下面该是我们的主角上场了，AutoResetEvent 和 ManualResetEvent，关于这两者我们暂且认为是差不多了，稍后我会介绍他们的不同，这里以AutoResetEvent为例，其实很多官方的说法太过于抽象，这里通俗地讲，可以认为AutoResetEvent就是一个公共的变量（尽管它是一个事件），创建的时候可以设置为false，然后在要等待的线程使用它的WaitOne方法，那么线程就一直会处于等待状态，只有这个AutoResetEvent被别的线程使用了Set方法，也就是要发通知的线程使用了它的Set方法，那么等待的线程就会往下执行了，Set就是发信号，WaitOne是等待信号，只有发了信号，等待的才会执行。如果不发的话，WaitOne后面的程序就永远不会执行。好下面看用AutoResetEvent改造上面的程序:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
 
namespace AutoResetEventTest
{
   class Class2
   {
     static AutoResetEvent mEvent= new AutoResetEvent( false );
     //static ManualResetEvent mEvent = new ManualResetEvent(false);
 
     static void DoWork()
     {
       Console.WriteLine( "  worker thread started, now waiting on event..." );
       mEvent.WaitOne();
       Console.WriteLine( "  worker thread reactivated, now exiting..." );
     }
 
     static void Main()
     {
       Console.WriteLine( "main thread starting worker thread..." );
       Thread t = new Thread(DoWork);
       t.Start();
 
       Console.WriteLine( "main thrad sleeping for 1 second..." );
       Thread.Sleep(1000);
 
       Console.WriteLine( "main thread signaling worker thread..." );
       mEvent.Set();
     }
   }
}

这时代码是不是清爽多了，这里其实你还会看到，把上面的AutoResetEvent换成ManualResetEvent也是没有问题的，那么它两之间的区别是什么呢？个人认为它们最大的区别在于，无论何时，只要 AutoResetEvent 激活线程，它的状态将自动从终止变为非终止。相反，ManualResetEvent 允许它的终止状态激活任意多个线程，只有当它的 Reset 方法被调用时才还原到非终止状态。开下面的代码:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
 
namespace AutoResetEventTest
{
   class Class3
   {
     static AutoResetEvent mEvent = new AutoResetEvent( false );
     //static ManualResetEvent mEvent = new ManualResetEvent(false);
 
     static void DoWork()
     {
       Console.WriteLine( "  worker thread started, now waiting on event..." );
       for ( int i = 0; i < 3; i++)
       {
         mEvent.WaitOne();
         //mEvent.Reset();
         Console.WriteLine( "  worker thread reactivated, now exiting..." );
       }
     }
 
     static void Main()
     {
       Console.WriteLine( "main thread starting worker thread..." );
       Thread t = new Thread(DoWork);
       t.Start();
 
       for ( int i = 0; i < 3; i++)
       {
         Thread.Sleep(1000);
         Console.WriteLine( "main thread signaling worker thread..." );
         mEvent.Set();
       }
     }
   }
}

如果你想仅仅把AutoResetEvent换成ManualResetEvent的话，你发现输出就会乱套了，为什么呢?

假如有autoevent.WaitOne()和manualevent.WaitOne()，当线程得到信号后都得以继续执行。差别就在调用后,autoevent.WaitOne()每次只允许一个线程进入，当某个线程得到信号(也就是有其他线程调用了autoevent.Set()方法后)后，autoevent会自动又将信号置为不发送状态，则其他调用WaitOne的线程只有继续等待，也就是说,autoevent一次只唤醒一个线程。而manualevent则可以唤醒多个线程，当某个线程调用了set方法后，其他调用waitone的线程获得信号得以继续执行，而manualevent不会自动将信号置为不发送，也就是说，除非手工调用了manualevent.Reset()方法，否则manualevent将一直保持有信号状态，manualevent也就可以同时唤醒多个线程继续执行.

在上面代码中，如果将AutoResetEvent换成ManualResetEvent的话，只要要在waitone后面做下reset，就会达到同样的效果.

之后咱们再来个简单的例子:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
 
namespace AutoResetEventTest
{
   class Class4
   {
     public static AutoResetEvent mEvent = new AutoResetEvent( false );
 
     public static void trmain()
     {
       Thread tr = Thread.CurrentThread;
       Console.WriteLine( "thread: waiting for an event" );
       mEvent.WaitOne();
       Console.WriteLine( "thread: got an event" );
       for ( int x = 0; x < 10; x++)
       {
         Thread.Sleep(1000);
         Console.WriteLine(tr.Name + ": " + x);
       }
     }
     static void Main( string [] args)
     {
       Thread thrd1 = new Thread( new ThreadStart(trmain));
       thrd1.Name = "thread1" ;
       thrd1.Start();
       for ( int x = 0; x < 10; x++)
       {
         Thread.Sleep(900);
         Console.WriteLine( "Main:" + x);
         if (5 == x) mEvent.Set();
       }
       while (thrd1.IsAlive)
       {
         Thread.Sleep(1000);
         Console.WriteLine( "Main: waiting for thread to stop" );
       }
     }
   }
}

是不是更有感觉了？之后咱来看看另外几个东东:

System.Threading.WaitHandle.WaitOne 使线程一直等待，直到单个事件变为终止状态； 。

System.Threading.WaitHandle.WaitAny 阻止线程，直到一个或多个指示的事件变为终止状态； 。

System.Threading.WaitHandle.WaitAll 阻止线程，直到所有指示的事件都变为终止状态.

然后再来个例子，以WaitAll使用为例:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
 
namespace AutoResetEventTest
{
   class other
   {
     static void Main( string [] args)
     {
       Random randomGenerator = new Random();
       AutoResetEvent[] resets= new AutoResetEvent[5];
 
       for ( int i = 0; i < 5; i++)
       {
         resets[i] = new AutoResetEvent( false );
         int wTime = randomGenerator.Next(10)+1;
 
         worker w = new worker(wTime, resets[i]);
 
         Thread thrd1 = new Thread( new ThreadStart(w.work));
         thrd1.Start(); 
       }
       WaitHandle.WaitAll(resets);
       Console.WriteLine( "ALL worker done - main exiting." );
     }
 
   }
 
   public class worker
   {
     public string name;
     public int wTime;
     public AutoResetEvent mEvent;
 
     public worker( int w, AutoResetEvent m)
     {
       name = w.ToString();
       wTime = w * 1000;
       mEvent = m;
     }
 
     public void work()
     {
       Console.WriteLine(name + " worker thread waiting for " + wTime + "...." );
       Thread.Sleep(wTime);
       Console.WriteLine(name + " worker thread back..." );
       mEvent.Set();
     }
   }
}

简单来说就是，开了5个线程，每个线程随机休眠若干秒，都完成后通知主线程退出，这里就开了一个AutoResetEvent数组，主线程就WaitHandle.WaitAll(resets) ，子线程休眠完后就Set1个AutoResetEvent，最后都Set完后，主线程就会往下执行。最后最后再来个买书付款取货的例子，加深理解:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
 
namespace AutoResetEventTest
{
   class Program
   {
     const int numIterations = 10;
     static AutoResetEvent myResetEvent = new AutoResetEvent( false );
     static AutoResetEvent ChangeEvent = new AutoResetEvent( false );
     //static ManualResetEvent myResetEvent = new ManualResetEvent(false);
     //static ManualResetEvent ChangeEvent = new ManualResetEvent(false);
     static int number; //这是关键资源
 
     static void Main()
     {
       Thread payMoneyThread = new Thread( new ThreadStart(PayMoneyProc));
       payMoneyThread.Name = "付钱线程" ;
       Thread getBookThread = new Thread( new ThreadStart(GetBookProc));
       getBookThread.Name = "取书线程" ;
       payMoneyThread.Start();
       getBookThread.Start();
 
       for ( int i = 1; i <= numIterations; i++)
       {
         Console.WriteLine( "买书线程：数量{0}" , i);
         number = i;
         //Signal that a value has been written.
         myResetEvent.Set();
         //ChangeEvent.Set();
         Thread.Sleep(10);
       }
       payMoneyThread.Abort();
       getBookThread.Abort();
     }
 
     static void PayMoneyProc()
     {
       while ( true )
       {
         myResetEvent.WaitOne();
         //myResetEvent.Reset();
         Console.WriteLine( "{0}：数量{1}" , Thread.CurrentThread.Name, number);
         ChangeEvent.Set();
       }
     }
     static void GetBookProc()
     {
       while ( true )
       {
         ChangeEvent.WaitOne();
         //ChangeEvent.Reset();        
         Console.WriteLine( "{0}：数量{1}" , Thread.CurrentThread.Name, number);
         Console.WriteLine( "------------------------------------------" );
         //Thread.Sleep(0);
       }
     }
   }
}

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

最后此篇关于详细解析C#多线程同步事件及等待句柄的文章就讲到这里了,如果你想了解更多关于详细解析C#多线程同步事件及等待句柄的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

30 4 0
文章推荐： c#几种数据库的大数据批量插入（SqlServer、Oracle、SQLite和MySql）
文章推荐： 关于Pyinstaller闪退的补救措施
文章推荐： python 使用百度AI接口进行人脸对比的步骤
文章推荐： 解决Pyinstaller打包为可执行文件编码错误的问题
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com