AutoResetEvent和ManualRestEvent

AutoResetEvent例子

class Program
    { //初始的时候是没有信号的，这里的意思是指参数false
        const int numIterations = 100;
        static AutoResetEvent myResetEvent = new AutoResetEvent(false);
        static int number;
      
        static void Main(string[] args)
        {
            Thread myReaderThread = new Thread(new ThreadStart(MyReadThreadProc));
            myReaderThread.Name = "ReaderThread";
            myReaderThread.Start();

            for (int i = 1; i <= numIterations; i++)
            {
                Console.WriteLine("Writer thread writing value: {0}", i);
                number = i;
                //发信号，说明值已经被写进去了。这里的意思是说Set是一个发信号的方法。
                myResetEvent.Set();              
                Thread.Sleep(0);
            }

            myReaderThread.Abort();
            Console.ReadKey();
        }

        static void MyReadThreadProc()
        {
            while (true)
            {    //在数据被作者写入之前不会被读者读取
                myResetEvent.WaitOne();
                Console.WriteLine("{0} reading value: {1}", Thread.CurrentThread.Name, number);
            }
        }
    }
1、AutoResetEvent这个类对象的定义的位置。
我们看到，这是一个简单的控制台程序，该程序只有一个类，该类有2个方法，一个是Main，另外一个是MyReadThreadProc，两个都是静态的。显然，第二个方法是准备用于线程的，也可以理解为，这段代码是一个线程的代码。有一个显著特点，就是一个无限循环：while(true){}。这实际暗示，这个程序将有2个线程，一个主线程，另外一个为读者线程。读者线程中除了WriteLine这一个方法，剩下的就是WaitOne()这个方法了。而myResetEvent这个对象定义在这个类中，在2个方法之外，也就是说线程方法和主线程代码都能够“看到”这个对象。
2、关于AutoResetEvent类对象的初始化
初始化需要注意的是，一般初始化为“未信号”，也就是所谓的“Not signaled”。关于这一点，文档的解释是“可以通过将一个布尔值传递给构造函数来控制 AutoResetEvent 的初始状态，如果初始状态为终止状态，则为 true；否则为 false。”也就是说Not Signaled=非终止状态。一般情况下我看大多数程序都是初始化为“非终止状态”的。这里面的原因很显然：非终止状态可以等待一个信号来释放线程，至于“终止状态”怎样目前还不清楚。
3、这个AutoResetEvent的类不能继承
这一点是规定没什么好解释的。
4、就是等待的问题
mResetEvent的等待是是用了WaitOne()方法，等待什么呢？等待一个线程发出Set()的方法，这里需要注意的是这2个线程是否都使用了同一个对象？是否必须像示例程序这样让需要通信的2个线程都看到这个信号对象？因为只有这样才能产生发信号和接收信号。
在等待的时候，会把当前的线程阻塞，这就是WaitOne()的作用，一旦等到某个线程Set()了，线程将继续，也就是说循环会继续下去。是否由于这段代码位于一个线程中，因此阻塞这个线程不会引起整个程序的阻塞吧。总之这里是一个相互配合的问题。
还有一个需要注意的是等待和初始状态相关，也就是初始状态必须是“非终止状态”
文档中的这一句话非常清楚了“如果 AutoResetEvent 处于非终止状态，则该线程阻塞，并等待当前控制资源的线程通过调用 Set 发出资源可用的信号。”
5、关键资源
文档中提到，这种技术常用在2个或者多个线程需要独占访问某系资源的情况下，比如串口等，这个例子中的独占访问的资源是什么呢？呵呵，代码中蓝色加重字体显示的就是所谓的需要独占访问的资源。我想把它叫做关键资源，不知道合适不合适。
  
ManualResetEvent 例子 i==5时运行新县城
class Program
    { 
       
        public static ManualResetEvent mre = new ManualResetEvent(false);
        static void Main(string[] args)
        {
            Thread tr1 = new Thread(new ThreadStart(TrMain));
            tr1.Name = "Tr1";
            tr1.Start();
            for (int i = 0; i < 10; i++)
            {
                Thread.Sleep(900);
                Console.WriteLine("Main:"+i.ToString());
                if (i == 5)
                {
                    mre.Set();
                }
            }
                Console.ReadKey();
        }

        public static void TrMain()
        {
            Thread tr = Thread.CurrentThread;
            mre.WaitOne();
            for (int x = 0; x < 10; x++)
            {
                Thread.Sleep(1000);
                Console.WriteLine(tr.Name + ": " + x);
            }
        }
    }


ManualResetEven和QueueUserWorkItem的例子
public static Boolean QueueUserWorkItem(WaitCallback wc, Object state);
   WaitCallback回调函数就是前文所阐述的应用程序，通过将一些回调函数放入线程池中让其形成队列，然后线程池会自动创建或者复用线程
class Program
    {
        static int count = 5;
        public static ManualResetEvent[] events = new ManualResetEvent[count];
        static void Main(string[] args)
        {
            Console.WriteLine("Main Thread id:{0}", Thread.CurrentThread.ManagedThreadId);
            for (int i = 0; i < count; i++)
            {              
                events[i] = new ManualResetEvent(false);
                Test tst = new Test(events[i]);
                Thread.Sleep(1000);
                ThreadPool.QueueUserWorkItem(tst.DisplayNumber, new { num = 2 });
            }
            ManualResetEvent.WaitAll(events);
            Console.ReadKey();
        } 

    }

    public class Test
    {
        ManualResetEvent manualEvent;
        public Test(ManualResetEvent manualEvent)
        {
            this.manualEvent = manualEvent;
        }
        public void DisplayNumber(object a)
        {
            Console.WriteLine("The num is " + ((dynamic)a).num);
            Console.WriteLine("Current thread is " + Thread.CurrentThread.ManagedThreadId);
            manualEvent.Set();
        }
    }

带Lock的例子
public object GetInstanceFromPool()
        {
            if (obPool.Count > 0)
            {
                lock (obPool)
                {
                    obPool.Dequeue();
                }
            }
            else 
            {
                AutoResetEvent auto = new AutoResetEvent(false);
                lock (waitList)
                {
                    waitList.Enqueue(auto);
                }
                auto.WaitOne();
            }

            return GetInstanceFromPool();
        }

        public void PutInstanceIntoPool(object obj)
        {
            lock (obPool)
            {
                obPool.Enqueue(obj);
            }
            if (waitList.Count > 0)
            {
                lock (waitList)
                {
                    waitList.Dequeue().Set();
                }
            }
        }

    }



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也就可以同时唤醒多个线程继续执行。