有关对耗时很大循环进行并行化优化的探讨 之一：并发搜索的处理

在对程序优化过程中，我们往往对循环体有着刻骨的仇恨，因为它对性能的损耗尤其之大，比如如下例程,是个简单的循环例程，全部执行需要30秒以上（痛苦）：

public enum HandleRst
{
完成,
错误_手术刀忘肚子里了,
失败_药物过敏,
失败_家属不签字,
}

public class Obj_Fath
{
private int _SonLen;

public int SonLen
{
get { return _SonLen; }
set { _SonLen = value; }
}

public Obj_Fath(string myt)
{
_T = myt;
_SonObjList = new List<Obj_Son>();
for (int i = 0; i < 1500; i++)
{
Obj_Son p = new Obj_Son(this );
_SonObjList.Add(p);
}
}

public HandleRst DoAsyncHandle()
{
HandleRst rst= HandleRst.完成;

if (_SonObjList.Count > 0)
{
foreach (Obj_Son son in _SonObjList)
{
HandleRst r = ComputeEachSon(son);
if (r != HandleRst.完成)
{
_ThisHandleRst = r;
break;
}
}
}
return rst ;
}

HandleRst ComputeEachSon(Obj_Son sonObj)
{
Thread.Sleep(1);
return sonObj.DoCompute();
}
}

public class Obj_Son
{
Obj_Fath _ObjFath;
public Obj_Son(Obj_Fath fathObj)
{
_ObjFath = fathObj;
}

public HandleRst DoCompute()
{
int len=0;
lock (_ObjFath )
{
_ObjFath.SonLen++;
len =_ObjFath .SonLen ;
}

Thread.Sleep (1);

if (len >1300)
{
return HandleRst.失败_家属不签字;
}
return HandleRst.完成;
}
}

但如何优化它呢，我们很容易想到要对循环体进行并发执行，即

foreach (Obj_Son son in _SonObjList)
{
Thread t =new Thread(ParameterThreadStart(ThreadCompute));
t.Start(son);
}
但这里带来了几个问题：
1） 如何获得ComputeEachSon方法的结果？
2） 如何在返回不为“完成”时立即退出循环？
貌似使用简单的多线程并发无法解决这个问题。

于是，我们想到了采用异步方法，改进后，执行的时间缩减到了6秒，效果还是不错的，附上简单的异步处理代码供大家研究改进。
bool _Tok;
ManualResetEvent _FinEvent;
private HandleRst _ThisHandleRst;
private int _HandleCount;

public HandleRst DoAsyncHandle()
{
_ThisHandleRst = HandleRst.完成;

_FinEvent = new ManualResetEvent(false);
_HandleCount = 0;

if (_SonObjList.Count > 0)
{
foreach (Obj_Son son in _SonObjList)
{
if (_Tok)
break;
HasSonComputingHandler h = new HasSonComputingHandler(ComputeEachSon);
HandleRst r = HandleRst.完成;
AsyncCallback t = new AsyncCallback(HandleCallBack);
h.BeginInvoke(son, t, h);
}
_FinEvent.WaitOne();
}
return _ThisHandleRst ;
}

void HandleCallBack(IAsyncResult iR)
{
if (_Tok)
return;

HasSonComputingHandler u = (HasSonComputingHandler)iR.AsyncState;
HandleRst r = u.EndInvoke(iR);
lock (this)
{
if (r != HandleRst.完成)
{
_ThisHandleRst = r;
_FinEvent.Set();
_Tok = true;
}

_HandleCount++;
if (_HandleCount == _SonObjList.Count)
{
_ThisHandleRst = r;
_FinEvent.Set();
_Tok = true;
}
}
}

试了一下异步操作循环体，发现了一个有趣的现象：
执行
Obj_Fath t = new Obj_Fath("hello");

HandleRst u= t.DoAsyncHandle();
MessageBox.Show("\n计数HandleCount：" +t.HandleCount .ToString ()+"\n计数Sonlen："+t.SonLen .ToString () +"\n" );
发现 HandeCount值在1298~1302之间
SonLen值在1306～1312之间。
如果顺序执行循环体，程序是在1300次循环时退出， 这说明
1）程序注册了2500个异步委托后，就直接进入阻塞等待状态。
2）完成退出当前方法后，未执行的异步委托会自动取消委托。
这样的话比起线程来说，就有很多好处了，因为发出线程是很难取消的。

更多请看

有关对耗时很大循环进行并行化优化的探讨之二：多重循环任务的并发处理 .