C#高并发测试代码

最近在研究高并发下，如何准确测得方法执行时间，我想到的办法是这样的：可以这样比喻3000名运动员再跑马拉松，起点还不同，突然跑道上到了一棵树，这棵树又恰好能拦住所有人，待所有人都跑到这颗树前的时候，树就挪开了，而此时运动员之间的距离就是最小的。
而我运用lock机制，达到这种效果，只可惜lock似乎对阻塞线程的队列有一定限制，队列满了就一定要放出一个，否则就会报出异常，而且队列大小似乎是2000~3000线程来着的。
代码如下：

using System;
using System.Collections.Generic;
using System.Threading;

namespace Test
{

//测试并发时间委托
public delegate void ConcurrencyTest();
/// <summary>
/// 高并发测试类
/// </summary>
public static class HighConcurrencyTest
{

/// <summary>
/// 测试高并发下单个委托的执行时间
/// </summary>
/// <param name="count">并发计数</param>
/// <param name="cTest">委托</param>
/// <param name="sizeThread">一个线程执行的估计时间，可以估计的大些，默认是6毫秒</param>
/// <returns></returns>
public static double StartTest(int count,ConcurrencyTest cTest,int sizeThread=6)
{
#region 为保证之后取得的时间准确度，初始化
ConcurrentLock cLock = new ConcurrentLock();
ConcurrentLock autoLock = new ConcurrentLock();
GC.Collect();
GC.Collect();
GC.Collect();
GC.Collect();
#endregion

#region 测算1亿次if时间，并按比例计算出时间差
int max = ((count + 1) * count) / 2;//if被操作的总次数
double stime = new TimeSpan(DateTime.Now.Ticks).TotalMilliseconds;
for (int i = 0; i < 100000000; i++)
{
if (cLock.EndTime == -1)
{
}
}
double etime = new TimeSpan(DateTime.Now.Ticks).TotalMilliseconds;
double ifSpan = ((etime - stime) / 100000000d) * max;
#endregion

#region 清理内存使用，再初始化
GC.Collect();
GC.Collect();
GC.Collect();
GC.Collect();
Thread.Sleep(3000);
#endregion

#region 执行，执行原理如下，因为线程开启的时间，各个线程之间存在时间差，现在采取一种办法，使其时间差只是一个if判断
List<Thread> threads = new List<Thread>();
int current = 0;
for (int i = 0; i < count; i++)
{
var thread = new Thread(() =>
{
//开始，挡路所有线程
lock (autoLock)
{
if (autoLock.StartTime == -1)
{
autoLock.StartTime = new TimeSpan(DateTime.Now.Ticks).TotalMilliseconds;
Thread.Sleep(sizeThread * count);
}
}
//释放挡路的路牌
#region 委托执行
cTest();
#endregion
//结束使用原子计数器
Interlocked.Increment(ref current);
if (current >= count)
{
//此时所有线程都运行完该委托
autoLock.EndTime = new TimeSpan(DateTime.Now.Ticks).TotalMilliseconds;
}
});
thread.IsBackground = true;
thread.SetApartmentState(ApartmentState.MTA);
threads.Add(thread);
}
foreach (var t in threads)
{
t.Start();
}
foreach (var t in threads)
{
t.Join();
}
#endregion

return (double)(autoLock.EndTime - autoLock.StartTime - sizeThread * count - ifSpan) / (double)count;
}
}

class ConcurrentLock
{
public double StartTime { get; set; }

public double EndTime { get; set; }

public ConcurrentLock()
{
StartTime = -1;
EndTime = -1;
}

public void Reset()
{
StartTime = -1;
EndTime = -1;
}
}
}