C#多线程同步事件及等待句柄 .

最新推荐文章于 2022-02-03 17:30:10 发布

Hustudent20080101

最新推荐文章于 2022-02-03 17:30:10 发布

阅读量491

点赞数

分类专栏： .NET C# 多线程

.NET 同时被 3 个专栏收录

424 篇文章 1 订阅

订阅专栏

348 篇文章 0 订阅

订阅专栏

多线程

67 篇文章 0 订阅

订阅专栏

C#多线程同步事件及等待句柄 .

标签：多线程同步

2013-10-29 16:39 14037人阅读评论(4) 收藏举报
.

分类：

.NET（34）

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

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

[csharp] view plain copy
01.using System;
02.using System.Collections.Generic;
03.using System.Text;
04.using System.Threading;
05.
06.namespace AutoResetEventTest
07.{
08.    class Class1
09.    {
10.        static bool flag = true;
11.
12.        static void DoWork()
13.        {
14.            Console.WriteLine("   worker thread started, now waiting on event...");
15.            while (flag)
16.            {
17.
18.            }
19.            Console.WriteLine("   worker thread reactivated, now exiting...");
20.        }
21.
22.        static void Main()
23.        {
24.            Console.WriteLine("main thread starting worker thread...");
25.            Thread t = new Thread(DoWork);
26.            t.Start();
27.
28.            Console.WriteLine("main thrad sleeping for 1 second...");
29.            Thread.Sleep(1000);
30.
31.            Console.WriteLine("main thread signaling worker thread...");
32.            flag = false;
33.        }
34.    }
35.}

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

[csharp] view plain copy
01.using System;
02.using System.Collections.Generic;
03.using System.Text;
04.using System.Threading;
05.
06.namespace AutoResetEventTest
07.{
08.    class Class2
09.    {
10.        static AutoResetEvent mEvent=new AutoResetEvent(false);
11.        //static ManualResetEvent mEvent = new ManualResetEvent(false);
12.
13.        static void DoWork()
14.        {
15.            Console.WriteLine("   worker thread started, now waiting on event...");
16.            mEvent.WaitOne();
17.            Console.WriteLine("   worker thread reactivated, now exiting...");
18.        }
19.
20.        static void Main()
21.        {
22.            Console.WriteLine("main thread starting worker thread...");
23.            Thread t = new Thread(DoWork);
24.            t.Start();
25.
26.            Console.WriteLine("main thrad sleeping for 1 second...");
27.            Thread.Sleep(1000);
28.
29.            Console.WriteLine("main thread signaling worker thread...");
30.            mEvent.Set();
31.        }
32.    }
33.}

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

[csharp] view plain copy
01.using System;
02.using System.Collections.Generic;
03.using System.Text;
04.using System.Threading;
05.
06.namespace AutoResetEventTest
07.{
08.    class Class3
09.    {
10.        static AutoResetEvent mEvent = new AutoResetEvent(false);
11.        //static ManualResetEvent mEvent = new ManualResetEvent(false);
12.
13.        static void DoWork()
14.        {
15.            Console.WriteLine("   worker thread started, now waiting on event...");
16.            for (int i = 0; i < 3; i++)
17.            {
18.                mEvent.WaitOne();
19.                //mEvent.Reset();
20.                Console.WriteLine("   worker thread reactivated, now exiting...");
21.            }
22.        }
23.
24.        static void Main()
25.        {
26.            Console.WriteLine("main thread starting worker thread...");
27.            Thread t = new Thread(DoWork);
28.            t.Start();
29.
30.            for (int i = 0; i < 3; i++)
31.            {
32.                Thread.Sleep(1000);
33.                Console.WriteLine("main thread signaling worker thread...");
34.                mEvent.Set();
35.            }
36.        }
37.    }
38.}

如果你想仅仅把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，就会达到同样的效果。

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

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

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

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

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

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

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

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

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

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

本文部分资料来源于网络，特此声明！

http://msdn.microsoft.com/zh-cn/library/z6w25xa6%28VS.80%29.aspx

.

顶8踩0.

基于遗传算法求解TSP问题（JAVA）

基于遗传算法求解TSP问题（C#界面）

我的同类文章

.NET（34）

?最新 IOS应用开发Icon规格自动裁剪器(C#)2014-09-26阅读2531
?C# Socket异步聊天例子2013-09-30阅读4431
?jQuery上传插件Uploadify 3.2在.NET下的详细例子2013-06-28阅读21235
?ASP.NET下在线编辑器FreeTextBox与FCKeditor快速使用2013-05-09阅读1928
?SQL Server 2005数据库附加改名2013-02-28阅读3090
?不安装OFFICE实现服务器读取EXCEL(ASP.NET)2014-03-17阅读4698
?asp.net中的各种数据绑定使用2013-06-30阅读5151
?jQuery EasyUI+ashx实现数据库的CIUD操作2013-06-25阅读19095
?easyui datagrid+ashx实现动态生成列2013-04-09阅读9152
?.NET下读取PDF文本总结2013-01-28阅读5635