多线程间通信之AutoResetEvent和ManualResetEvent的原理分析和开发示例(转)

http://www.cnblogs.com/springyangwc/archive/2011/10/12/2208991.html

概述

AutoResetEvent 允许线程通过发信号互相通信。通常，当线程需要独占访问资源时使用该类。

线程通过调用 AutoResetEvent 上的 WaitOne 来等待信号。如果 AutoResetEvent 为非终止状态，则线程会被阻止，并等待当前控制资源的线程通过调用 Set 来通知资源可用。

调用 Set 向 AutoResetEvent 发信号以释放等待线程。 AutoResetEvent 将保持终止状态，直到一个正在等待的线程被释放，然后自动返回非终止状态。如果没有任何线程在等待，则状态将无限期地保持为终止状态。

如果当 AutoResetEvent 为终止状态时线程调用 WaitOne，则线程不会被阻止。 AutoResetEvent 将立即释放线程并返回到非终止状态。

ManualResetEvent 允许线程通过发信号互相通信。通常，此通信涉及一个线程在其他线程进行之前必须完成的任务。

当一个线程开始一个活动（此活动必须完成后，其他线程才能开始）时，它调用 Reset 以将 ManualResetEvent 置于非终止状态。此线程可被视为控制 ManualResetEvent。调用 ManualResetEvent 上的 WaitOne 的线程将阻止，并等待信号。当控制线程完成活动时，它调用Set 以发出等待线程可以继续进行的信号。并释放所有等待线程。

一旦它被终止，ManualResetEvent 将保持终止状态，直到它被手动重置。即对 WaitOne 的调用将立即返回。

可以通过将布尔值传递给构造函数来控制 ManualResetEvent 的初始状态，如果初始状态处于终止状态，为 true；否则为 false。

ManualResetEvent 也可以同 staticWaitAll 和 WaitAny 方法一起使用。

生活中的例子

AutoResetEvent ：在上海坐地铁,检票口有个刷卡的通道,一次只能一个人刷卡后通过,而我过后,它又是关闭的,另一个人又得再刷卡.一次操作,只有一个事件,这时就是非终止状态，一般是用来同步访问资源.

ManualResetEvent :公司园区的大门很大，一次可以多人通过。

ManualResetEvent和AutoResetEvent 比较

ManualResetEvent和AutoResetEvent都继承自EventWaitHandler，它们的唯一区别就在于父类 EventWaitHandler的构造函数参数EventResetMode不同，这样我们只要弄清了参数EventResetMode值不同时，EventWaitHandler类控制线程同步的行为有什么不同，两个子类也就清楚了。

共同点：
A、Set方法将事件状态设置为终止状态，允许一个或多个等待线程继续；Reset方法将事件状态设置为非终止状态，导致线程阻止；WaitOne阻止当前线程，直到当前线程的WaitHandler收到事件信号。
B、可以通过构造函数的参数值来决定其初始状态，若为true则事件为终止状态从而使线程为非阻塞状态，为false则线程为阻塞状态。
C、如果某个线程调用WaitOne方法，则当事件状态为终止状态时，该线程会得到信号，继续向下执行。

不同点：
A、AutoResetEvent.WaitOne()每次只允许一个线程进入，当某个线程得到信号后，AutoResetEvent会自动又将信号置为不发送状态，则其他调用WaitOne的线程只有继续等待，也就是说 AutoResetEvent一次只唤醒一个线程；
B、ManualResetEvent则可以唤醒多个线程，因为当某个线程调用了ManualResetEvent.Set()方法后，其他调用WaitOne的线程获得信号得以继续执行，而ManualResetEvent不会自动将信号置为不发送。

C、也就是说，除非手工调用了ManualResetEvent.Reset()方法，则ManualResetEvent将一直保持有信号状态，ManualResetEvent也就可以同时唤醒多个线程继续执行。

先看下AutoResetEvent 的代码

01
namespace System.Threading {

02
  
03
    using System; 

04
    using System.Security.Permissions;

05
    using System.Runtime.InteropServices; 

06
 
07
    [HostProtection(Synchronization=true, ExternalThreading=true)]

08
    [System.Runtime.InteropServices.ComVisible(true)]

09
    public sealed class AutoResetEvent : EventWaitHandle 

10
    {

11
        public AutoResetEvent(bool initialState) : base(initialState,EventResetMode.AutoReset){ } 

12
    } 

13
}

再来看下EventWaitHandle的代码

001
namespace System.Threading 

002
{ 

003
    using System;

004
    using System.Threading; 

005
    using System.Runtime.CompilerServices;

006
    using System.Security.Permissions;

007
    using System.IO;

008
    using Microsoft.Win32; 

009
    using Microsoft.Win32.SafeHandles;

010
    using System.Runtime.InteropServices; 

011
    using System.Runtime.Versioning; 

012
#if !FEATURE_PAL

013
    using System.Security.AccessControl; 

014
#endif

015
 
016
    [HostProtection(Synchronization=true, ExternalThreading=true)]

017
    [ComVisibleAttribute(true)] 

018
    public class EventWaitHandle : WaitHandle

019
    { 

020
        [ResourceExposure(ResourceScope.None)] 

021
        [ResourceConsumption(ResourceScope.Machine, ResourceScope.Machine)]

022
        public EventWaitHandle(bool initialState, EventResetMode mode) : this(initialState,mode,null) { } 

023
 
024
        [SecurityPermissionAttribute(SecurityAction.LinkDemand,Flags=SecurityPermissionFlag.UnmanagedCode)]

025
        [ResourceExposure(ResourceScope.Machine)]

026
        [ResourceConsumption(ResourceScope.Machine)] 

027
        public EventWaitHandle(bool initialState, EventResetMode mode, string name)

028
        { 

029
            if(null != name && System.IO.Path.MAX_PATH < name.Length) 

030
            {

031
                throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong",name)); 

032
            }

033
 
034
            SafeWaitHandle _handle = null;

035
            switch(mode) 

036
            {

037
                case EventResetMode.ManualReset: 

038
                    _handle = Win32Native.CreateEvent(null, true, initialState, name); 

039
                    break;

040
                case EventResetMode.AutoReset: 

041
                    _handle = Win32Native.CreateEvent(null, false, initialState, name);

042
                    break;

043
 
044
                default: 

045
                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag",name));

046
            }; 

047
  
048
            if (_handle.IsInvalid)

049
            { 

050
                int errorCode = Marshal.GetLastWin32Error();

051
 
052
                _handle.SetHandleAsInvalid();

053
                if(null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode) 

054
                    throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle",name));

055
  
056
                __Error.WinIOError(errorCode, ""); 

057
            }   

058
            SetHandleInternal(_handle); 

059
        }

060
 
061
        [SecurityPermissionAttribute(SecurityAction.LinkDemand,Flags=SecurityPermissionFlag.UnmanagedCode)]

062
        [ResourceExposure(ResourceScope.Machine)] 

063
        [ResourceConsumption(ResourceScope.Machine)]

064
        public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew) 

065
#if !FEATURE_PAL 

066
            : this(initialState, mode, name, out createdNew, null)

067
        { 

068
        }

069
 
070
        [SecurityPermissionAttribute(SecurityAction.LinkDemand,Flags=SecurityPermissionFlag.UnmanagedCode)]

071
        [ResourceExposure(ResourceScope.Machine)] 

072
        [ResourceConsumption(ResourceScope.Machine)]

073
        public unsafe EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew, EventWaitHandleSecurity eventSecurity) 

074
#endif 

075
        {

076
            if(null != name && System.IO.Path.MAX_PATH < name.Length) 

077
            {

078
                throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong",name));

079
            }

080
            Win32Native.SECURITY_ATTRIBUTES secAttrs = null; 

081
#if !FEATURE_PAL

082
            // For ACL's, get the security descriptor from the EventWaitHandleSecurity. 

083
            if (eventSecurity != null) { 

084
                secAttrs = new Win32Native.SECURITY_ATTRIBUTES();

085
                secAttrs.nLength = (int)Marshal.SizeOf(secAttrs); 

086
 
087
                byte[] sd = eventSecurity.GetSecurityDescriptorBinaryForm();

088
                byte* pSecDescriptor = stackalloc byte[sd.Length];

089
                Buffer.memcpy(sd, 0, pSecDescriptor, 0, sd.Length); 

090
                secAttrs.pSecurityDescriptor = pSecDescriptor;

091
            } 

092
#endif 

093
 
094
            SafeWaitHandle _handle = null; 

095
            Boolean isManualReset;

096
            switch(mode)

097
            {

098
                case EventResetMode.ManualReset: 

099
                    isManualReset = true;

100
                    break; 

101
                case EventResetMode.AutoReset: 

102
                    isManualReset = false;

103
                    break; 

104
 
105
                default:

106
                    throw new ArgumentException(Environment.GetResourceString("Argument_InvalidFlag",name));

107
            }; 

108
 
109
            _handle = Win32Native.CreateEvent(secAttrs, isManualReset, initialState, name); 

110
            int errorCode = Marshal.GetLastWin32Error(); 

111
 
112
            if (_handle.IsInvalid) 

113
            {

114
 
115
                _handle.SetHandleAsInvalid();

116
                if(null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode) 

117
                    throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle",name));

118
  
119
                __Error.WinIOError(errorCode, name); 

120
            }

121
            createdNew = errorCode != Win32Native.ERROR_ALREADY_EXISTS; 

122
            SetHandleInternal(_handle);

123
        }

124
 
125
        private EventWaitHandle(SafeWaitHandle handle) 

126
        {

127
            SetHandleInternal(handle); 

128
        } 

129
 
130
        [SecurityPermissionAttribute(SecurityAction.LinkDemand,Flags=SecurityPermissionFlag.UnmanagedCode)] 

131
        [ResourceExposure(ResourceScope.Machine)]

132
        [ResourceConsumption(ResourceScope.Machine)]

133
        public static EventWaitHandle OpenExisting(string name)

134
        { 

135
#if !FEATURE_PAL

136
            return OpenExisting(name, EventWaitHandleRights.Modify | EventWaitHandleRights.Synchronize); 

137
        } 

138
 
139
        [SecurityPermissionAttribute(SecurityAction.LinkDemand,Flags=SecurityPermissionFlag.UnmanagedCode)] 

140
        [ResourceExposure(ResourceScope.Machine)]

141
        [ResourceConsumption(ResourceScope.Machine)]

142
        public static EventWaitHandle OpenExisting(string name, EventWaitHandleRights rights)

143
        { 

144
#endif  // !FEATURE_PAL

145
            if (name == null) 

146
            { 

147
                throw new ArgumentNullException("name", Environment.GetResourceString("ArgumentNull_WithParamName"));

148
            } 

149
 
150
            if(name.Length  == 0)

151
            {

152
                throw new ArgumentException(Environment.GetResourceString("Argument_EmptyName"), "name"); 

153
            }

154
  
155
            if(null != name && System.IO.Path.MAX_PATH < name.Length) 

156
            {

157
                throw new ArgumentException(Environment.GetResourceString("Argument_WaitHandleNameTooLong",name)); 

158
            }

159
 
160
 
161
#if FEATURE_PAL 

162
            SafeWaitHandle myHandle = Win32Native.OpenEvent(Win32Native.EVENT_MODIFY_STATE | Win32Native.SYNCHRONIZE, false, name);

163
#else 

164
            SafeWaitHandle myHandle = Win32Native.OpenEvent((int) rights, false, name); 

165
#endif

166
  
167
            if (myHandle.IsInvalid)

168
            {

169
                int errorCode = Marshal.GetLastWin32Error();

170
  
171
                if(Win32Native.ERROR_FILE_NOT_FOUND == errorCode || Win32Native.ERROR_INVALID_NAME == errorCode)

172
                    throw new WaitHandleCannotBeOpenedException(); 

173
                if(null != name && 0 != name.Length && Win32Native.ERROR_INVALID_HANDLE == errorCode) 

174
                    throw new WaitHandleCannotBeOpenedException(Environment.GetResourceString("Threading.WaitHandleCannotBeOpenedException_InvalidHandle",name));

175
                //this is for passed through Win32Native Errors 

176
                __Error.WinIOError(errorCode,"");

177
            }

178
            return new EventWaitHandle(myHandle);

179
        } 

180
        public bool Reset()

181
        { 

182
            bool res = Win32Native.ResetEvent(safeWaitHandle); 

183
            if (!res)

184
                __Error.WinIOError(); 

185
            return res;

186
        }

187
        public bool Set()

188
        { 

189
            bool res = Win32Native.SetEvent(safeWaitHandle);

190
  
191
            if (!res) 

192
                __Error.WinIOError();

193
  
194
            return res;

195
        }

196
 
197
#if !FEATURE_PAL 

198
        public EventWaitHandleSecurity GetAccessControl()

199
        { 

200
            return new EventWaitHandleSecurity(safeWaitHandle, AccessControlSections.Access | AccessControlSections.Owner | AccessControlSections.Group); 

201
        }

202
  
203
        public void SetAccessControl(EventWaitHandleSecurity eventSecurity)

204
        {

205
            if (eventSecurity == null)

206
                throw new ArgumentNullException("eventSecurity"); 

207
 
208
            eventSecurity.Persist(safeWaitHandle); 

209
        } 

210
#endif

211
    } 

212
}

再来看下ManualResetEvent的代码

01
namespace System.Threading {

02
  
03
    using System; 

04
    using System.Security.Permissions;

05
    using System.Runtime.InteropServices; 

06
 
07
    [HostProtection(Synchronization=true, ExternalThreading=true)]

08
[System.Runtime.InteropServices.ComVisible(true)]

09
    public sealed class ManualResetEvent : EventWaitHandle 

10
    {

11
        public ManualResetEvent(bool initialState) : base(initialState,EventResetMode.ManualReset){} 

12
    } 

13
}

其实这两个的差别就是AutoResetEvent是base(initialState,EventResetMode.AutoReset)而 ManualResetEvent是base(initialState,EventResetMode.ManualReset).

AutoResetEvent是操作单个线程的，而ManualResetEvent可以操作多个线程.

AutoResetEvent开发示例

在主线程运行后，新开一个新线程，由新线程来控制主线程的等待和执行.

类关系图

代码实现

001
//===============================================================================

002
//作者：Spring Yang

003
//日期：2011-10-12

004
//===============================================================================

005
namespace TestMultipleThread

006
{

007
    using System;

008
    using System.Collections.Generic;

009
    using System.Threading;

010
    public class ThreadWork

011
    {

012
        private MainContext mainContext;

013
        private ContextCache contextCache;

014
 
015
        public ThreadWork()

016
        {

017
            contextCache = ContextCache.GetContextCache();

018
            mainContext = contextCache.GetContextByUserId("001");

019
        }

020
 
021
        public void Sum()

022
        {

023
            Console.WriteLine(string.Format("this is thread ID {0}  execute", Thread.CurrentThread.ManagedThreadId));

024
            for (int i = 0; i < 10; i++)

025
            {

026
                Thread.Sleep(10);

027
            }

028
            if (mainContext != null && mainContext.IsCrawlWait == false)

029
            {

030
                mainContext.IsNTFSEvent = true;

031
                while (mainContext.IsCrawlWait)

032
                {

033
                    Thread.Sleep(25);

034
                }

035
 
036
                Console.WriteLine("main thread is wait");

037
                Thread.Sleep(10000);

038
                Console.WriteLine("main thread is start");

039
                mainContext.IsNTFSEvent = false;

040
                mainContext.SetThread();

041
            }

042
 
043
        }

044
    }

045
 
046
    class Program

047
    {

048
        public static void Main()

049
        {

050
            MainContext mainContext = new MainContext("001");

051
            mainContext.Save();

052
 
053
            //新开一个线程

054
            ThreadWork threadWork = new ThreadWork();

055
            ThreadStart myThreadDelegate = new ThreadStart(threadWork.Sum);

056
            Thread myThread = new Thread(myThreadDelegate);

057
            myThread.Start();

058
 
059
            for (int i = 0; i < 100; i++)

060
            {

061
                if (mainContext.IsNTFSEvent)

062
                    mainContext.ThreadWait();

063
                Thread.Sleep(10);

064
            }

065
 
066
            Console.WriteLine("main Thread continue");

067
            Thread.Sleep(100000);

068
        }

069
 
070
 
071
 
072
        public void WriteMessage()

073
        {

074
            Console.WriteLine("Stop the main thread.");

075
        }

076
    }

077
 
078
    public class MainContext

079
    {

080
        public string UserId { get; set; }

081
        //设置 AutoResetEvent

082
        public AutoResetEvent WaitEvent;

083
 
084
        public ContextCache contextCache;

085
 
086
        //设置线程等待

087
        public void ThreadWait()

088
        {

089
            if (WaitEvent == null) WaitEvent = new AutoResetEvent(false);

090
 
091
            if (IsNTFSEvent)

092
            {

093
                IsCrawlWait = true;

094
                WaitEvent.WaitOne();

095
            }

096
        }

097
 
098
        public MainContext(string userID)

099
        {

100
            UserId = userID;

101
            IsCrawlWait = false;

102
            IsNTFSEvent = false;

103
            contextCache = ContextCache.GetContextCache();

104
        }

105
 
106
        public void Save()

107
        {

108
            contextCache.Save(UserId, this);

109
        }

110
 
111
        public void SetThread()

112
        {

113
 
114
            if (!IsNTFSEvent && IsCrawlWait)

115
            {

116
                IsCrawlWait = false;

117
                WaitEvent.Set();

118
            }

119
        }

120
 
121
        public bool IsCrawlWait { get; set; }

122
 
123
        public bool IsNTFSEvent { get; set; }

124
 
125
    }

126
 
127
    //单例模式，保存到内存中

128
    public class ContextCache

129
    {

130
        public Dictionary<string, MainContext> dicMainContext = new Dictionary<string, MainContext>();

131
 
132
        public void Save(string userId, MainContext mainContext)

133
        {

134
            dicMainContext.Add(userId, mainContext);

135
        }

136
 
137
        private static ContextCache singleContextCache;

138
 
139
        public MainContext GetContextByUserId(string userId)

140
        {

141
            MainContext context;

142
            dicMainContext.TryGetValue(userId, out context);

143
            return context;

144
        }

145
 
146
        private ContextCache()

147
        {

148
        }

149
 
150
        public static ContextCache GetContextCache()

151
        {

152
            if (singleContextCache == null)

153
            {

154
                singleContextCache = new ContextCache();

155
            }

156
            return singleContextCache;

157
        }

158
    }

159
}