线程同步-等待所有线程执行完毕

在多线程程序中经常会碰到线程同步：

场景1

主线程启动多个子线程后，主线程需要等待所有的子线程执行完毕后，主线程才能进一步向下执行。

C# 提供了 ManualResetEvent 类为我们的线程同步提供了方便.

ManualResetEvent.WaitAll(new WaitHandle[] { });

 

WaitAll静态方法提供了阻塞当前线程的执行，直到WaitHandle[]中的每个线程发送了阻塞解除的信号，当前线程才会继续执行。

 

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

 

ManualResetEvent.Set() 方法发送阻塞终止的信号，当其它线程收到线程阻塞解除的信号，就会继续执行。

 

 

场景：主线程需要对子线程1产生的数据与子线程2产生的数据求和，主线程启动线程1等待生成数据1，启动线程2等待生成数据2，只有当

数据1与数据2生成后，主线程才能对数据求和。

 

代码如下：

using System;



using System.Collections.Generic;



using System.Linq;



using System.Text;



using System.Threading;



using System.Diagnostics;



namespace ThreadStudy.Hbb0b0



{



    /// <summary>



    /// 本事例说明主线程如何等待辅助线程都执行完毕之后继续执行。



    /// 主线程启动辅助线程1生成加数1，启动辅助线程2生成加数2



    /// 主线程等待辅助线程1与辅助线程2的生成的加数之后，对加数



    /// 进行累加，并输出结果。



    /// </summary>



    class Program



    {



        delegate int operateNumber(int a, int b);



        delegate int generateNumber(int a);



        static int result1;



        static int result2;



        static void Main(string[] args)



        {



            //辅助线程1阻塞标志



            ManualResetEvent m1 = new ManualResetEvent(false);



           



            //辅助线程2的阻塞标志



            ManualResetEvent m2 = new ManualResetEvent(false);



 



            generateNumber g1 = ThreadTool.GenerateNumber;



            generateNumber g2 = ThreadTool.GenerateNumber;



            AsyncCallback g1_callback = delegate(IAsyncResult ar)



            {



                result1 = g1.EndInvoke(ar);



                Console.WriteLine("thread id:{0} current number:{1} block stop", Thread.CurrentThread.ManagedThreadId, result1);



                //辅助线程阻塞完毕



                m1.Set();



            };



            AsyncCallback g2_callback = delegate(IAsyncResult ar)



            {



                result2 = g2.EndInvoke(ar);



                Console.WriteLine("thread id:{0} current number:{1} block stop", Thread.CurrentThread.ManagedThreadId, result2);



                //辅助线程阻塞完毕



                m2.Set();



            };



            Console.WriteLine("generate numbers:");



 



            //辅助线程1启动



            g1.BeginInvoke(10, g1_callback, null);



           



            //辅助线程2启动



            g2.BeginInvoke(100, g2_callback, null);



 



            //主线线程等待所有辅助线程回归



            ManualResetEvent.WaitAll(new WaitHandle[] { m1, m2 });



 



            int sum= ThreadTool.sum(result1, result2);



            Console.WriteLine("{0}+{1}={2}", result1, result2, sum);



 



            Console.Read();



 



        }



    }



    public class ThreadTool



    {



        /// <summary>



        /// 生成数字



        /// </summary>



        /// <param name="maxNum"></param>



        /// <returns></returns>



        static public int GenerateNumber(int maxNum)



        {



            Console.WriteLine("thread Id:{0} generate number", Thread.CurrentThread.ManagedThreadId);



            Thread.Sleep(5000);



        



            int result = new Random((int)DateTime.Now.Ticks).Next(maxNum);



            return result;



        }



        /// <summary>



        /// 累加结果



        /// </summary>



        /// <param name="a"></param>



        /// <param name="b"></param>



        /// <returns></returns>



        static public int sum(int a, int b)



        {



            Console.WriteLine("thread Id:{0} gernerate number", Thread.CurrentThread.ManagedThreadId);



            Thread.Sleep(6000);



            return a + b;



        }



    }



}

 

 

 

场景2 ：

主线程启动子线程1，子线程2, 只要子线程1或子线程2 任一线程执行完毕，主线程就可以继续执行。

 

代码如下：

using System;



using System.Collections.Generic;



using System.Linq;



using System.Text;



using System.Threading;



namespace ThreadWaitOne



{



 



    class ThreadStartParameterInfo



    {



        /// <summary>



        /// 线程信号



        /// </summary>



        public ManualResetEvent m_mr;



       



        /// <summary>



        /// 线程等待时间



        /// </summary>



        public int m_waitTicks;



        public ThreadStartParameterInfo(ManualResetEvent mr,int waitTicks)



        {



            m_mr = mr;



            m_waitTicks = waitTicks;



          



        }



    }



 



    public class ThreadTool



    {



        private object m_SyncObject = new object();



        private int currentThreadId = -1;



        public void Main()



        {



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



            {



                ManualResetEvent mr1 = new ManualResetEvent(false);



                ManualResetEvent mr2 = new ManualResetEvent(false);



                ManualResetEvent mr3 = new ManualResetEvent(false);



                ParameterizedThreadStart pts1 = new ParameterizedThreadStart(this.GenerateNumber);



                ParameterizedThreadStart pts2 = new ParameterizedThreadStart(this.GenerateNumber);



                ParameterizedThreadStart pts3 = new ParameterizedThreadStart(this.GenerateNumber);



                Thread ts1 = new Thread(pts1);



                Thread ts2 = new Thread(pts1);



                Thread ts3 = new Thread(pts1);



                ts1.Start (new ThreadStartParameterInfo(mr1, 3010));



                ts2.Start(new ThreadStartParameterInfo(mr2, 3020));



                ts3.Start(new ThreadStartParameterInfo(mr3, 3030));



                //主线程等待任一线程，任一线程发送阻塞完成信号后，主线程就可以继续执行



                ManualResetEvent.WaitAny(new WaitHandle[] { mr1, mr2, mr3 });



 



                Console.WriteLine("Main Thread: The fast thread:{0}", currentThreadId);



            }



           



        }



 



        public void GenerateNumber(object  resetEvent)



        {



            ThreadStartParameterInfo threadInfo = resetEvent as ThreadStartParameterInfo;



            //ManualResetEvent mr = resetEvent as ManualResetEvent;



            Console.WriteLine("thread Id:{0} wait:{1} generate number start:.....", Thread.CurrentThread.ManagedThreadId,threadInfo.m_waitTicks);



           



            Thread.Sleep(threadInfo.m_waitTicks);



            int radomNumber = new Random((int)DateTime.Now.Ticks).Next(1000);



            lock(m_SyncObject)



            {



                currentThreadId = Thread.CurrentThread.ManagedThreadId;



            }



            Console.WriteLine("thread Id:{0} generate number:{1}", Thread.CurrentThread.ManagedThreadId, radomNumber);



            threadInfo.m_mr.Set();



        }



    }



}