EventWaitHandle使用方法小记

　　在项目制作的过程中，由于程序需要处理的数据量比较大，所以采用异步的方式来进行，也就是利用委托的BeginInvoke方法和EndInvoke方法来进行。效果很不错，达到了预期。但是由于程序在运行的时候，需要先加载数据，数据加载完成以后，然后进行数据比对差异，并对有差异的数据进行着色处理，在这儿，问题就来了。

　　什么问题呢？我们知道，当利用异步的时候，实际上系统会自动为我们创建前后台交互线程，那么这个数据加载和差异着色就运行在了这样的线程之上，所以二者的运行先后顺序是不可知的，事实上，程序中着色的混乱也验证了这一点：那就是我虽然原本想让数据加载完成后在进行代码差异着色，可是实际运行的时候发现，数据是边加载边着色的，这也归咎到如何将多个线程合并为一个并且按序运行的问题。

　　数据加载的异步代码如下：

 //start to perform async action
        private void BeginDealDataInformation(ListView listview,string fileName,EnumX enums)
        {
            DealDataInformationDelegateAsync dAsync = new DealDataInformationDelegateAsync(DealDataInformation);
            IAsyncResult iar = dAsync.BeginInvoke(listview,fileName,enums,new AsyncCallback(EndDealDataInformation),dAsync);
            
            if ((enumThis = enums) == EnumX.leftSide) tsStatus.Text = "正在加载左边文件的数据，请等待...";
            if ((enumThis = enums) == EnumX.rightSide) tsStatus.Text = "正在加载右边文件的数据，请等待...";
        }

        //returen the async running result
        private void EndDealDataInformation(IAsyncResult iar)
        {
            UIThread.UIInvoke(this.toolStrip1, delegate
            {
                if (enumThis == EnumX.leftSide) tsStatus.Text = "左边数据加载完毕，请继续下面操作...";
                if (enumThis == EnumX.rightSide) tsStatus.Text = "右边数据加载完毕，请继续下面操作...";
            });
            DealDataInformationDelegateAsync dAsync = (DealDataInformationDelegateAsync)iar.AsyncState;
            dAsync.EndInvoke(iar);
        }


        //this is a function that takes a lot of time to run, need to use async action to perform it.
        private void DealDataInformation(ListView listview,string fileName,EnumX enums)
        {
            //myHandle.Reset();//让其他需要等待的线程阻塞
            if (ColumnHeaderCollection == null) throw new Exception("文件内容为空或者不以逗号分隔！！！");

            int columnCount = ColumnHeaderCollection.Length;
            for (int i = 0; i < columnCount; i++)
            {
                ColumnHeader header = new ColumnHeader();
                header.Text = ColumnHeaderCollection[i];
                header.TextAlign = HorizontalAlignment.Left;

                UIThread.UIInvoke(listview, delegate {
                    listview.Columns.Add(header);               
                });
            }

            int tryResult;

            using (StreamReader sr = new StreamReader(fileName, Encoding.Default))
            {
                string result;
                while ((result = sr.ReadLine()) != null)
                {
                    string[] _result = result.Split(',');
                    ListViewItem lvi = new ListViewItem(_result[0]);

                    if (Int32.TryParse(_result[0], out tryResult))
                    {
                        if (enums == EnumX.leftSide) DataCache.cacheRecordListOne.Add(Int32.Parse(_result[0]));  //cache the record
                        if (enums == EnumX.rightSide) DataCache.cacheRecordListTwo.Add(Int32.Parse(_result[0]));  //cache the record
                    }

                    for (int j = 1; j < _result.Length; j++)
                    {
                        lvi.SubItems.Add(_result[j]);
                    }

                    //add items
                    UIThread.UIInvoke(listview, delegate
                    {
                        listview.Items.Add(lvi);
                        if (enums == EnumX.leftSide)  DataCache.listItemLeft.Add(lvi);
                        if (enums == EnumX.rightSide) DataCache.listItemRight.Add(lvi);
                    });
                }
            }

            //remove the first item(commonly, it's a header)
            UIThread.UIInvoke(listview, delegate
            {
                listview.Items.RemoveAt(0);
                //DataCache.listItemLeft.RemoveAt(0);
                //DataCache.listItemRight.RemoveAt(0);
            });
            //myHandle.Set();  //允许其他等待的线程运行
        }

 这里我们可以看到需要传入3个参数。

差异着色的异步处理方法如下：

 private void ColorTheResultAsync(EnumX enums,ListView listview)
        {
            //myHandle.WaitOne(); //处于等待状态，直到收到Set的信号
            CommonUntil commonUntil = new CommonUntil();
            List<int> existList=null;
            List<int> nonExistList = null;

            if (enums == EnumX.leftSide)
            {
                 existList = commonUntil.ReturnComparisonResult(DataCache.cacheRecordListOne, DataCache.cacheRecordListTwo)[0];
                 nonExistList=commonUntil.ReturnComparisonResult(DataCache.cacheRecordListOne, DataCache.cacheRecordListTwo)[1];

                listPartOne[0] = existList;
                listPartOne[1] = nonExistList;
            }

            if (enums == EnumX.rightSide)
            {

                existList = commonUntil.ReturnComparisonResult(DataCache.cacheRecordListTwo, DataCache.cacheRecordListOne)[0];
                nonExistList = commonUntil.ReturnComparisonResult(DataCache.cacheRecordListTwo, DataCache.cacheRecordListOne)[1];

                listPartTwo[0] = existList;
                listPartTwo[1] = nonExistList;
            }
            
            int __result;
            UIThread.UIInvoke(listview, delegate
            {
                
                foreach (ListViewItem lvi in listview.Items)
                {

                    if (Int32.TryParse(lvi.Text, out __result))
                    {
                        if (existList.Contains(Int32.Parse(lvi.Text)))
                        {
                            if (enums == EnumX.leftSide) lvi.BackColor = Color.Wheat;
                            if (enums == EnumX.rightSide) lvi.BackColor = Color.YellowGreen;
                        }
                    }
                }
                listview.Invalidate();
            });
        }

        private void BeginColorTheResultAsync(EnumX enums,ListView listview)
        {
            ColorTheResultDelegateAsync colorTheResultAsync = new ColorTheResultDelegateAsync(ColorTheResultAsync);
            IAsyncResult iar = colorTheResultAsync.BeginInvoke(enums, listview, new AsyncCallback(EndColorTheResultAsync),colorTheResultAsync);

            tsStatus.Text = "正在着色中，请等待...";
        }

        private void EndColorTheResultAsync(IAsyncResult iar)
        {
            tsStatus.Text = "着色完毕，请检测...";
            ColorTheResultDelegateAsync colorTheResultAsync = (ColorTheResultDelegateAsync)iar.AsyncState;
            colorTheResultAsync.EndInvoke(iar);
        }

　　可以看到需要两个参数来运行。

　　本来想直接开两个线程，然后利用Thread的join方法将线程合并为一个，然后顺序运行，以达到需要的效果，但是需要传至少两个参数进去，查看了一下ParameterizedThreadStart，发现结尾只能带一个object类型的参数，但是由于我这里传入的多于一个(虽然可以将这些参数用类包装起来，当作object传过去，但是那样确实比较麻烦，我还不确定这个程序需要不需要扩展呢)，于是只要寻找别的方法。

　　在查资料的过程中，我突然想到一个类：EventWaitHandle，也就是本文的主角。

　　这个类通过在线程之间设置信号量，可以非常方便的控制线程运行的顺序。具体代码如下：

　　首先全局申明：

 EventWaitHandle myHandle = new EventWaitHandle(false, EventResetMode.ManualReset);  //将信号状态置为非终止，使用手动重置

　　其次在大数据处理的函数开始加上

 myHandle.Reset();//让其他需要等待的线程阻塞

　　末尾加上：

myHandle.Set();  //允许其他等待的线程运行

　　具体形式如下：

 private void DealDataInformation(ListView listview,string fileName,EnumX enums)
 {
       myHandle.Reset();//让其他需要等待的线程阻塞
　　　　....................
       myHandle.Set();  //允许其他等待的线程运行
  }

　　其中Reset方法可以让本函数进行处理，而让其他在线程上的未接收到信号量的函数进入阻塞状态，而Set方法则是释放信号量，以便通知阻塞线程当前处理结束，可以继续进行。

　　那么怎么控制哪些函数需要阻塞呢？ 很简单：

　　直接在函数的入口处加上：

private void ColorTheResultAsync(EnumX enums,ListView listview)
{
        myHandle.WaitOne(); //处于等待状态，直到收到Set的信号
      .........
}

就表明只有当承载DealDataInformation函数的线程运行完毕，承载ColorTheResultAsync函数的线程才可以开始运行，这样就做到了顺序运行。