private void QueueWorkItems(IWorkItemsGroup group, IEnumerable <Action> actionGroup)
{
foreach (Action action in actionGroup)
{
Action action_ = action;
group.QueueWorkItem(
o =>
{
try
{
action_();
}
catch (Exception e)
{
ExecutionException = e;
bool abort = false;
if (OnException != null)
{
OnException(e, out abort);
}
group.Cancel(abort);
}
return(null);
},
this,
wi =>
{
//if (wi.Exception != null) { }
});
}
}
public void WorkItemWaitCanceling()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
ManualResetEvent cancelWaitHandle = new ManualResetEvent(false);
bool success = false;
// Queue a work item that will occupy the thread in the pool
IWorkItemResult wir1 =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
// Queue another work item that will wait for the first to complete
IWorkItemResult wir2 =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.SignalCancel), cancelWaitHandle);
try
{
wir1.GetResult(Crestron.SimplSharp.Timeout.Infinite, true, cancelWaitHandle);
}
catch (WorkItemTimeoutException)
{
success = true;
}
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
/// <summary>
/// Create a new work item
/// </summary>
/// <param name = "wigStartInfo">Work item group start information</param>
/// <param name = "callback">A callback to execute</param>
/// <returns>Returns a work item</returns>
public static WorkItem CreateWorkItem(
IWorkItemsGroup workItemsGroup,
WIGStartInfo wigStartInfo,
WorkItemCallback callback)
{
return CreateWorkItem(workItemsGroup, wigStartInfo, callback, null);
}
/// <summary>
/// 实例化QueueService
/// </summary>
/// <param name="smart"></param>
/// <param name="logger"></param>
/// <param name="service"></param>
/// <param name="elapsedTime"></param>
public AsyncService(IWorkItemsGroup group, ILog logger, IService service, TimeSpan elapsedTime)
{
this.smart = group;
this.logger = logger;
this.service = service;
this.elapsedTime = elapsedTime;
}
public int Choice(IEnumerable <Action> actions)
{
WIGStartInfo wigStartInfo = new WIGStartInfo
{
StartSuspended = true
};
IWorkItemsGroup workItemsGroup = this.CreateWorkItemsGroup(2147483647, wigStartInfo);
ManualResetEvent anActionCompleted = new ManualResetEvent(false);
SmartThreadPool.ChoiceIndex choiceIndex = new SmartThreadPool.ChoiceIndex();
int num = 0;
foreach (Action current in actions)
{
Action act = current;
int value = num;
workItemsGroup.QueueWorkItem(delegate
{
act();
Interlocked.CompareExchange(ref choiceIndex._index, value, -1);
anActionCompleted.Set();
});
num++;
}
workItemsGroup.Start();
anActionCompleted.WaitOne();
return(choiceIndex._index);
}
public void DontDisposeCallerState()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
WIGStartInfo wigStartInfo = new WIGStartInfo();
wigStartInfo.DisposeOfStateObjects = false;
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue, wigStartInfo);
CallerState nonDisposableCallerState = new NonDisposableCallerState();
CallerState disposableCallerState = new DisposableCallerState();
IWorkItemResult wir1 =
workItemsGroup.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
nonDisposableCallerState);
IWorkItemResult wir2 =
workItemsGroup.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
disposableCallerState);
wir1.GetResult();
bool success = (1 == nonDisposableCallerState.Value);
wir2.GetResult();
success = success && (1 == disposableCallerState.Value);
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
/// <summary>
/// Create a new work item
/// </summary>
/// <param name = "wigStartInfo">Work item group start information</param>
/// <param name = "callback">A callback to execute</param>
/// <param name = "state">
/// The context object of the work item. Used for passing arguments to the work item.
/// </param>
/// <param name = "postExecuteWorkItemCallback">
/// A delegate to call after the callback completion
/// </param>
/// <param name = "callToPostExecute">Indicates on which cases to call to the post execute callback</param>
/// <param name = "workItemPriority">The work item priority</param>
/// <returns>Returns a work item</returns>
public static WorkItem CreateWorkItem(
IWorkItemsGroup workItemsGroup,
WIGStartInfo wigStartInfo,
WorkItemCallback callback,
object state,
PostExecuteWorkItemCallback postExecuteWorkItemCallback,
CallToPostExecute callToPostExecute,
WorkItemPriority workItemPriority)
{
ValidateCallback(callback);
ValidateCallback(postExecuteWorkItemCallback);
WorkItemInfo workItemInfo = new WorkItemInfo
{
UseCallerCallContext = wigStartInfo.UseCallerCallContext,
UseCallerHttpContext = wigStartInfo.UseCallerHttpContext,
PostExecuteWorkItemCallback = postExecuteWorkItemCallback,
CallToPostExecute = callToPostExecute,
WorkItemPriority = workItemPriority,
DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects
};
WorkItem workItem = new WorkItem(
workItemsGroup,
workItemInfo,
callback,
state);
return(workItem);
}
/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="workItemsGroup">The workItemGroup of the workitem</param>
/// <param name="workItemInfo">The WorkItemInfo of te workitem</param>
/// <param name="callback">Action delegate for the callback.</param>
/// <param name="state">Items with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(
IWorkItemsGroup workItemsGroup,
WorkItemInfo workItemInfo,
WorkItemCallback callback,
object state)
{
if (null == workItemInfo)
{
throw new ArgumentNullException("workItemInfo");
}
_workItemsGroup = workItemsGroup;
_workItemInfo = workItemInfo;
#if !(_WINDOWS_CE) && !(_SILVERLIGHT)
if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext)
{
_callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext);
}
#endif
_callback = callback;
_state = state;
_workItemResult = new WorkItemResult(this);
Initialize();
}
/// <summary>
/// Create a new work item
/// </summary>
/// <param name="workItemsGroup"></param>
/// <param name="wigStartInfo">Work item group start information</param>
/// <param name="callback">A callback to execute</param>
/// <param name="state">
/// The context object of the work item. Used for passing arguments to the work item.
/// </param>
/// <param name="workItemPriority">The work item priority</param>
/// <returns>Returns a work item</returns>
public static WorkItem CreateWorkItem(IWorkItemsGroup workItemsGroup, WIGStartInfo wigStartInfo, WorkItemCallback callback, object state, WorkItemPriority workItemPriority)
{
ValidateCallback(callback);
return(new WorkItem(workItemsGroup, new WorkItemInfo {
UseCallerCallContext = wigStartInfo.UseCallerCallContext, UseCallerHttpContext = wigStartInfo.UseCallerHttpContext, PostExecuteWorkItemCallback = wigStartInfo.PostExecuteWorkItemCallback, CallToPostExecute = wigStartInfo.CallToPostExecute, DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects, WorkItemPriority = workItemPriority
}, callback, state));
}
public void ExceptionThrowing()
{
STP smartThreadPool = new STP();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
DivArgs divArgs = new DivArgs
{
x = 10,
y = 0
};
IWorkItemResult wir =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoDiv), divArgs);
try
{
wir.GetResult();
}
catch (WorkItemResultException wire)
{
Assert.IsTrue(wire.InnerException is DivideByZeroException);
return;
}
catch (Exception e)
{
e.GetHashCode();
Assert.Fail();
}
Assert.Fail();
}
//IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, PostExecuteWorkItemCallback postExecuteWorkItemCallback, WorkItemPriority workItemPriority);
public static void TestQueueWorkItemCallStatPostPrio(IWorkItemsGroup wig)
{
bool postExecuteCalled = false;
object state = new object();
PostExecuteWorkItemCallback postExecuteWorkItemCallback = delegate(IWorkItemResult w) { postExecuteCalled = true; };
WorkItemInfo wii = new WorkItemInfo();
wii.WorkItemPriority = WorkItemPriority.BelowNormal;
wii.PostExecuteWorkItemCallback = postExecuteWorkItemCallback;
WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii, state);
IWorkItemResult wir = wig.QueueWorkItem(
wiic.CompareWorkItemInfo,
state,
postExecuteWorkItemCallback,
WorkItemPriority.BelowNormal);
// We must wait for idle to let the post execute run
wig.WaitForIdle();
bool success = (bool)wir.Result;
Assert.IsTrue(success);
Assert.IsTrue(postExecuteCalled);
}
private void btnStart_Click(object sender, System.EventArgs e)
{
UpdateControls(true);
workItemsCompleted = 0;
workItemsGenerated = 0;
STPStartInfo stpStartInfo = new STPStartInfo();
stpStartInfo.IdleTimeout = Convert.ToInt32(spinIdleTimeout.Value) * 1000;
stpStartInfo.MaxWorkerThreads = Convert.ToInt32(spinMaxThreads.Value);
stpStartInfo.MinWorkerThreads = Convert.ToInt32(spinMinThreads.Value);
if (_useWindowsPerformanceCounters)
{
stpStartInfo.PerformanceCounterInstanceName = "Test SmartThreadPool";
}
else
{
stpStartInfo.EnableLocalPerformanceCounters = true;
}
_smartThreadPool = new SmartThreadPool(stpStartInfo);
//_workItemsGroup = _smartThreadPool.CreateWorkItemsGroup(1);
_workItemsGroup = _smartThreadPool;
workItemsProducerThread = new Thread(new ThreadStart(this.WorkItemsProducer));
workItemsProducerThread.IsBackground = true;
workItemsProducerThread.Start();
}
public void ExceptionReturning()
{
bool success = true;
STP smartThreadPool = new STP();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
DivArgs divArgs = new DivArgs
{
x = 10,
y = 0
};
IWorkItemResult wir =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoDiv), divArgs);
Exception e = null;
try
{
wir.GetResult(out e);
}
catch (Exception ex)
{
ex.GetHashCode();
success = false;
}
Assert.IsTrue(success);
Assert.IsTrue(e is DivideByZeroException);
}
private void spinCon_ValueChanged(object sender, EventArgs e)
{
NumericUpDown spin = sender as NumericUpDown;
IWorkItemsGroup wig = spin.Tag as IWorkItemsGroup;
wig.Concurrency = (int)spin.Value;
}
private void Dispose(bool disposing)
{
if (this.disposed)
{
return;
}
if (disposing)
{
if (this.schedulerThread != null)
{
this.schedulerThread.Abort();
this.schedulerThread = (Thread)null;
}
if (this.processingGroup != null)
{
this.processingGroup.Cancel(false);
this.processingGroup = (IWorkItemsGroup)null;
}
if (this.processingThreadPool != null)
{
this.processingThreadPool.Dispose();
this.processingThreadPool = (SmartThreadPool)null;
}
}
this.disposed = true;
}
/// <summary>
/// Example of how to use the post execute callback
/// </summary>
private bool DoTestPostExecute(CallToPostExecute callToPostExecute, bool answer)
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
bool success = false;
PostExecuteResult postExecuteResult = new PostExecuteResult();
IWorkItemResult wir =
workItemsGroup.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
postExecuteResult,
new PostExecuteWorkItemCallback(this.DoSomePostExecuteWork),
callToPostExecute);
if (!wir.IsCompleted)
{
int result = (int)wir.GetResult();
success = (1 == result);
success = success && (postExecuteResult.wh.WaitOne(1000, true) == answer);
}
smartThreadPool.Shutdown();
return(success);
}
private void WorkItemsProducer()
{
WorkItemCallback workItemCallback = DoWork;
while (running)
{
IWorkItemsGroup workItemsGroup = _stp;
if (null == workItemsGroup)
{
return;
}
try
{
workItemsGroup.QueueWorkItem(workItemCallback);
}
catch (ObjectDisposedException e)
{
e.GetHashCode();
break;
}
workItemsGenerated++;
Thread.Sleep(_interval);
}
}
private void WorkItemsProducer()
{
WorkItemCallback workItemCallback = new WorkItemCallback(this.DoWork);
while (running)
{
IWorkItemsGroup workItemsGroup = _workItemsGroup;
if (null == workItemsGroup)
{
return;
}
try
{
workItemCallback = new WorkItemCallback(this.DoWork);
workItemsGroup.QueueWorkItem(workItemCallback);
}
catch (ObjectDisposedException e)
{
e.GetHashCode();
break;
}
workItemsGenerated++;
Thread.Sleep(Convert.ToInt32(spinInterval.Value));
}
}
private void ValidateWorkItemsGroupWaitForIdleImpl(IWorkItemsGroup workItemsGroup, WorkItem workItem)
{
if (((workItemsGroup != null) && (workItem != null)) && workItem.WasQueuedBy(workItemsGroup))
{
throw new NotSupportedException("WaitForIdle cannot be called from a thread on its SmartThreadPool, it will cause may cause a deadlock");
}
}
public Boolean reparse()
{
lock (_lock)
{
Boolean result = true;
if (!Constant.RunStatus.STOP.Equals(this.RunStatus))
{
result = false;
}
else
{
this.workItemsGroup = ThreadPoolEx.getWorkItemsGroup();
this.WaitQueue = new Hashtable();
this.StartQueue = new Hashtable();
this.successQueue = new Hashtable();
this.errorQueue = new Hashtable();
this.RunStatus = Constant.RunStatus.RUNING;
}
return(result);
}
}
public void STPAndWIGStartSuspended()
{
STPStartInfo stpStartInfo = new STPStartInfo();
stpStartInfo.StartSuspended = true;
SmartThreadPool stp = new SmartThreadPool(stpStartInfo);
WIGStartInfo wigStartInfo = new WIGStartInfo();
wigStartInfo.StartSuspended = true;
IWorkItemsGroup wig = stp.CreateWorkItemsGroup(10, wigStartInfo);
wig.QueueWorkItem(new WorkItemCallback(this.DoWork));
Assert.IsFalse(wig.WaitForIdle(200));
wig.Start();
Assert.IsFalse(wig.WaitForIdle(200));
stp.Start();
Assert.IsTrue(wig.WaitForIdle(5000), "WIG is not idle");
Assert.IsTrue(stp.WaitForIdle(5000), "STP is not idle");
}
/// <summary>
/// Create a new work item
/// </summary>
/// <param name="workItemsGroup">The WorkItemsGroup of this workitem</param>
/// <param name="wigStartInfo">Work item group start information</param>
/// <param name="callback">A callback to execute</param>
/// <returns>Returns a work item</returns>
public static WorkItem CreateWorkItem(
IWorkItemsGroup workItemsGroup,
WIGStartInfo wigStartInfo,
WorkItemCallback callback)
{
return(CreateWorkItem(workItemsGroup, wigStartInfo, callback, null));
}
public void WaitAny()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
bool success = false;
IWorkItemResult [] wirs = new IWorkItemResult[5];
for (int i = 0; i < wirs.Length; ++i)
{
wirs[i] =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
}
int index = SmartThreadPool.WaitAny(wirs);
if (wirs[index].IsCompleted)
{
int result = (int)wirs[index].GetResult();
if (1 == result)
{
success = true;
}
}
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
private void materialRaisedButton11_Click(object sender, EventArgs e)
{
startTime = System.DateTime.Now;
running = true;
UpdateControls(true);
workItemsCompleted = 0;
workItemsGenerated = 0;
STPStartInfo stpStartInfo = new STPStartInfo();
stpStartInfo.IdleTimeout = Convert.ToInt32(materialSingleLineTextField4.Text) * 1000;
stpStartInfo.MaxWorkerThreads = Convert.ToInt32(materialSingleLineTextField5.Text);
stpStartInfo.MinWorkerThreads = 0;
if (_useWindowsPerformanceCounters)
{
stpStartInfo.PerformanceCounterInstanceName = "测试线程池工具";
}
else
{
stpStartInfo.EnableLocalPerformanceCounters = true;
}
_smartThreadPool = new SmartThreadPool(stpStartInfo);
_workItemsGroup = _smartThreadPool;
workItemsProducerThread = new Thread(new ThreadStart(this.WorkItemsProducer));
workItemsProducerThread.IsBackground = true;
workItemsProducerThread.Start();
}
public void TwoWIGsStartSuspended()
{
SmartThreadPool stp = new SmartThreadPool();
WIGStartInfo wigStartInfo = new WIGStartInfo();
wigStartInfo.StartSuspended = true;
IWorkItemsGroup wig1 = stp.CreateWorkItemsGroup(10, wigStartInfo);
IWorkItemsGroup wig2 = stp.CreateWorkItemsGroup(10, wigStartInfo);
wig1.QueueWorkItem(new WorkItemCallback(this.DoWork));
wig2.QueueWorkItem(new WorkItemCallback(this.DoWork));
Assert.IsFalse(wig1.WaitForIdle(200));
Assert.IsFalse(wig2.WaitForIdle(200));
wig1.Start();
Assert.IsTrue(wig1.WaitForIdle(200));
Assert.IsFalse(wig2.WaitForIdle(200));
wig2.Start();
Assert.IsTrue(wig1.WaitForIdle(0));
Assert.IsTrue(wig2.WaitForIdle(200));
}
/// <summary>
/// 后台消息业务处理对象启动
/// </summary>
/// <returns></returns>
public bool InitServer()
{
try
{
//获取线程空闲超时时间（单位：秒）、最大线程数
_idleTimeout = 10;
_maxWorkerThreads = 10;
}
catch (Exception ex)
{
//写日志（预留），不退出
}
//////////////////////////////////////////////////////////////////////////////////////////////////
try
{
STPStartInfo stpStartInfo = new STPStartInfo();
stpStartInfo.IdleTimeout = _idleTimeout * 2000;
stpStartInfo.MaxWorkerThreads = _maxWorkerThreads;
stpStartInfo.MinWorkerThreads = _minWorkerThreads;
stpStartInfo.PerformanceCounterInstanceName = "Pool";
_smartThreadPool = new SmartThreadPool(stpStartInfo);
_workItemsGroup = _smartThreadPool;
//线程池启动成功，写日志（预留）
return(true);
}
catch (Exception ex)
{
//Helper.Log.SaveException("Exception", ex);
//写日志（预留）
return(false);
}
}
/// <summary>
/// Create a new work item
/// </summary>
/// <param name="workItemsGroup">The WorkItemsGroup of this workitem</param>
/// <param name="wigStartInfo">Work item group start information</param>
/// <param name="callback">A callback to execute</param>
/// <param name="state">
/// The context object of the work item. Used for passing arguments to the work item.
/// </param>
/// <returns>Returns a work item</returns>
public static WorkItem CreateWorkItem(
IWorkItemsGroup workItemsGroup,
WIGStartInfo wigStartInfo,
WorkItemCallback callback,
object state)
{
ValidateCallback(callback);
WorkItemInfo workItemInfo = new WorkItemInfo();
workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext;
workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext;
workItemInfo.PostExecuteWorkItemCallback = wigStartInfo.PostExecuteWorkItemCallback;
workItemInfo.CallToPostExecute = wigStartInfo.CallToPostExecute;
workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects;
workItemInfo.WorkItemPriority = wigStartInfo.WorkItemPriority;
WorkItem workItem = new WorkItem(
workItemsGroup,
workItemInfo,
callback,
state);
return(workItem);
}
internal void UnregisterWorkItemsGroup(IWorkItemsGroup workItemsGroup)
{
if (_workItemsGroups.Contains(workItemsGroup))
{
_workItemsGroups.Remove(workItemsGroup);
}
}
public void TestWIGConcurrencyChange()
{
STP smartThreadPool = new STP(10 * 1000, 25, 0);
IWorkItemsGroup wig = smartThreadPool.CreateWorkItemsGroup(smartThreadPool.MaxThreads);
bool success = false;
for (int i = 0; i < 100; ++i)
{
wig.QueueWorkItem(new WorkItemCallback(this.DoSomeLongWork), null);
}
wig.Concurrency = 1;
success = WaitForWIGThreadsInUse(wig, 1, 1 * 1000);
Assert.IsTrue(success);
wig.Concurrency = 5;
success = WaitForWIGThreadsInUse(wig, 5, 2 * 1000);
Assert.IsTrue(success);
wig.Concurrency = 25;
success = WaitForWIGThreadsInUse(wig, 25, 4 * 1000);
Assert.IsTrue(success);
wig.Concurrency = 10;
success = WaitForWIGThreadsInUse(wig, 10, 10 * 1000);
Assert.IsTrue(success);
smartThreadPool.Shutdown();
}
public void StopMonitorFolder()
{
if (_fSWatcher != null)
{
_fSWatcher.EnableRaisingEvents = false;
_fSWatcher.Created -= new FileSystemEventHandler(FSWatcher_Created);
_fSWatcher = null;
this.FMSObjStatus = "Stop";
}
if ((_processFileWIG != null))
{
_processFileWIG.Cancel(true);
_processFileWIG = null;
}
if (_sMTPool != null)
{
_sMTPool.Shutdown();
_sMTPool = null;
}
if ((_processingFileList != null))
{
_processingFileList = null;
}
}
public void WaitForIdleOnSTPThreadForAnotherWorkItemsGroup()
{
SmartThreadPool smartThreadPool = new SmartThreadPool(10 * 1000, 25, 0);
IWorkItemsGroup workItemsGroup1 = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
IWorkItemsGroup workItemsGroup2 = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
workItemsGroup1.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
1000);
workItemsGroup1.QueueWorkItem(
new WorkItemCallback(this.DoSomeWork),
1000);
IWorkItemResult wir = workItemsGroup2.QueueWorkItem(
new WorkItemCallback(this.DoWaitForIdle),
workItemsGroup1);
Exception e;
wir.GetResult(out e);
smartThreadPool.Shutdown();
Assert.IsNull(e);
}
private object DoWaitForIdle(object state)
{
IWorkItemsGroup workItemsGroup = state as IWorkItemsGroup;
workItemsGroup.WaitForIdle();
return(null);
}
public void Init()
{
_stp = new SmartThreadPool();
WIGStartInfo wigStartInfo = new WIGStartInfo();
wigStartInfo.FillStateWithArgs = true;
_wig = _stp.CreateWorkItemsGroup(10, wigStartInfo);
}
/// <summary>
/// HttpServiceCaller初始化
/// </summary>
/// <param name="group"></param>
/// <param name="config"></param>
/// <param name="container"></param>
public HttpServiceCaller(IWorkItemsGroup group, CastleServiceConfiguration config, IServiceContainer container)
{
this.config = config;
this.container = container;
this.smart = group;
this.callers = new HttpCallerInfoCollection();
this.callTimeouts = new Dictionary<string, int>();
}
/// <summary>
/// QuickSort array using wig to parallel the sort
/// </summary>
/// <param name="wig">A IWorkItemsGroup to use to parallel the sort</param>
/// <param name="array">The array of items to sort</param>
public static void QuickSort(IWorkItemsGroup wig, int[] array)
{
// Initiate the QuickSort
wig.QueueWorkItem(QuickSort, wig, array, 0, array.Length - 1);
// Wait for the sort to complete.
wig.WaitForIdle();
}
public WigEntry(
IWorkItemsGroup wig,
QueueUsageControl queueUsageControl,
Label isIdle)
{
_wig = wig;
_queueUsageControl = queueUsageControl;
_isIdle = isIdle;
}
public HashCalculator(IHashAlgorithm method, SmartThreadPool pool)
{
_method = method;
_pool = pool;
if(_hashGroup == null)
{
_hashGroup = _pool.CreateWorkItemsGroup(1);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkGroupWithItem"/> class.
/// </summary>
/// <param name="sourceGroup">The source group.</param>
/// <param name="threadGroup">The thread group.</param>
/// <param name="metricCounter">A counter for tracking how many items are being processed</param>
public WorkGroupWithItem(IWorkGroup sourceGroup, IWorkItemsGroup threadGroup, ICounter metricCounter)
{
Guard.NotNull(() => sourceGroup, sourceGroup);
Guard.NotNull(() => threadGroup, threadGroup);
Guard.NotNull(() => metricCounter, metricCounter);
GroupInfo = sourceGroup;
Group = threadGroup;
MaxWorkItems = GroupInfo.ConcurrencyLevel + GroupInfo.MaxQueueSize;
MetricCounter = metricCounter;
}
/// <summary>
/// Sort a subarray in array, starting with the left item and ending in the right item.
/// The method uses the IWorkItemsGroup wig to parallel the sort.
/// </summary>
/// <param name="wig">A IWorkItemsGroup to use to parallel the sort</param>
/// <param name="array">The array of items to sort</param>
/// <param name="left">The left index in the subarray</param>
/// <param name="right">The right index in the subarray</param>
private static void QuickSort(IWorkItemsGroup wig, int[] array, int left, int right)
{
if (right > left)
{
int pivotIndex = left;
int pivotNewIndex = Partition(array, left, right, pivotIndex);
wig.QueueWorkItem(QuickSort, wig, array, left, pivotNewIndex - 1);
wig.QueueWorkItem(QuickSort, wig, array, pivotNewIndex + 1, right);
}
}
//IWorkItemResult QueueWorkItem(WorkItemCallback callback);
public static void TestQueueWorkItemCall(IWorkItemsGroup wig)
{
WorkItemInfo wii = new WorkItemInfo();
WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii);
IWorkItemResult wir = wig.QueueWorkItem(wiic.CompareWorkItemInfo);
bool success = (bool)wir.Result;
Assert.IsTrue(success);
}
//IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state);
public static void TestQueueWorkItemCallStat(IWorkItemsGroup wig)
{
object state = new object();
WorkItemInfo wii = new WorkItemInfo();
WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii, state);
IWorkItemResult wir = wig.QueueWorkItem((WorkItemCallback) wiic.CompareWorkItemInfo, state);
bool success = (bool)wir.Result;
Assert.IsTrue(success);
}
//IWorkItemResult QueueWorkItem(WorkItemCallback callback, WorkItemPriority workItemPriority);
public static void TestQueueWorkItemCallPrio(IWorkItemsGroup wig)
{
WorkItemInfo wii = new WorkItemInfo();
wii.WorkItemPriority = WorkItemPriority.AboveNormal;
WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii);
IWorkItemResult wir = wig.QueueWorkItem((WorkItemCallback)wiic.CompareWorkItemInfo, WorkItemPriority.AboveNormal);
bool success = (bool)wir.Result;
Assert.IsTrue(success);
}
//IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, WorkItemPriority workItemPriority);
public static void TestQueueWorkItemCallStatPrio(IWorkItemsGroup wig)
{
object state = new object();
WorkItemInfo wii = new WorkItemInfo();
wii.WorkItemPriority = WorkItemPriority.AboveNormal;
WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii, state);
IWorkItemResult wir = wig.QueueWorkItem(wiic.CompareWorkItemInfo, state, WorkItemPriority.AboveNormal);
bool success = (bool)wir.Result;
Assert.IsTrue(success);
}
// Token: 0x0600185F RID: 6239
// RVA: 0x00075274 File Offset: 0x00073474
public static WorkItem CreateWorkItem(IWorkItemsGroup iworkItemsGroup_0, WIGStartInfo wigstartInfo_0, WorkItemCallback workItemCallback_0, object object_0, WorkItemPriority workItemPriority_0)
{
WorkItemFactory.ValidateCallback(workItemCallback_0);
return new WorkItem(iworkItemsGroup_0, new WorkItemInfo
{
UseCallerCallContext = wigstartInfo_0.UseCallerCallContext,
UseCallerHttpContext = wigstartInfo_0.UseCallerHttpContext,
PostExecuteWorkItemCallback = wigstartInfo_0.PostExecuteWorkItemCallback,
CallToPostExecute = wigstartInfo_0.CallToPostExecute,
DisposeOfStateObjects = wigstartInfo_0.DisposeOfStateObjects,
WorkItemPriority = workItemPriority_0
}, workItemCallback_0, object_0);
}
/// <summary>
/// 初始化ServiceCaller
/// </summary>
/// <param name="group"></param>
/// <param name="status"></param>
public ServiceCaller(IWorkItemsGroup group, ServerStatusService status)
{
this.status = status;
this.smart = group;
this.callbackTypes = new Dictionary<string, Type>();
this.callTimeouts = new Dictionary<string, int>();
//初始化服务
InitServiceCaller(status.Container);
//注册状态服务
var hashtable = new Dictionary<Type, object>();
hashtable[typeof(IStatusService)] = status;
//注册组件
status.Container.RegisterComponents(hashtable);
}
private void Concurrency(
int concurrencyPerWig,
int wigsCount,
int workItemsCount)
{
Console.WriteLine(
"Testing : concurrencyPerWig = {0}, wigsCount = {1}, workItemsCount = {2}",
concurrencyPerWig,
wigsCount,
workItemsCount);
_success = true;
_concurrencyPerWig = concurrencyPerWig;
_randGen = new Random(0);
STPStartInfo stpStartInfo = new STPStartInfo();
stpStartInfo.StartSuspended = true;
SmartThreadPool stp = new SmartThreadPool(stpStartInfo);
_concurrentOps = new int[wigsCount];
IWorkItemsGroup [] wigs = new IWorkItemsGroup[wigsCount];
for(int i = 0; i < wigs.Length; ++i)
{
wigs[i] = stp.CreateWorkItemsGroup(_concurrencyPerWig);
for(int j = 0; j < workItemsCount; ++j)
{
wigs[i].QueueWorkItem(new WorkItemCallback(this.DoWork), i);
}
wigs[i].Start();
}
stp.Start();
stp.WaitForIdle();
Assert.IsTrue(_success);
stp.Shutdown();
}
//IWorkItemResult QueueWorkItem(WorkItemCallback callback, object state, PostExecuteWorkItemCallback postExecuteWorkItemCallback);
public static void TestQueueWorkItemCallStatPost(IWorkItemsGroup wig)
{
bool postExecuteCalled = false;
object state = new object();
PostExecuteWorkItemCallback postExecuteWorkItemCallback = delegate(IWorkItemResult w) { postExecuteCalled = true; };
WorkItemInfo wii = new WorkItemInfo();
wii.PostExecuteWorkItemCallback = postExecuteWorkItemCallback;
WorkItemInfoComparer wiic = new WorkItemInfoComparer(wii, state);
IWorkItemResult wir = wig.QueueWorkItem(
wiic.CompareWorkItemInfo,
state,
postExecuteWorkItemCallback);
// We must wait for idle to let the post execute run
wig.WaitForIdle();
bool success = (bool)wir.Result;
Assert.IsTrue(success);
Assert.IsTrue(postExecuteCalled);
}
/// <summary>
/// Create a new work item
/// </summary>
/// <param name="workItemsGroup"></param>
/// <param name="wigStartInfo">Work item group start information</param>
/// <param name="callback">A callback to execute</param>
/// <param name="state">
/// The context object of the work item. Used for passing arguments to the work item.
/// </param>
/// <returns>Returns a work item</returns>
public static WorkItem CreateWorkItem(
IWorkItemsGroup workItemsGroup,
WIGStartInfo wigStartInfo,
WorkItemCallback callback,
object state)
{
ValidateCallback(callback);
WorkItemInfo workItemInfo = new WorkItemInfo();
workItemInfo.UseCallerCallContext = wigStartInfo.UseCallerCallContext;
workItemInfo.UseCallerHttpContext = wigStartInfo.UseCallerHttpContext;
workItemInfo.PostExecuteWorkItemCallback = wigStartInfo.PostExecuteWorkItemCallback;
workItemInfo.CallToPostExecute = wigStartInfo.CallToPostExecute;
workItemInfo.DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects;
WorkItem workItem = new WorkItem(
workItemsGroup,
workItemInfo,
callback,
state);
return workItem;
}
/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="workItemsGroup"></param>
/// <param name="workItemInfo"></param>
/// <param name="callback">Callback delegate for the callback.</param>
/// <param name="state">State with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(
IWorkItemsGroup workItemsGroup,
WorkItemInfo workItemInfo,
WorkItemCallback callback,
object state)
{
_workItemsGroup = workItemsGroup;
_workItemInfo = workItemInfo;
if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext)
{
_callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext);
}
_callback = callback;
_state = state;
_workItemResult = new WorkItemResult(this);
Initialize();
}
private void InitSTP()
{
STPStartInfo stpStartInfo =
new STPStartInfo
{
StartSuspended = true,
MaxWorkerThreads = ((int)spinCon6.Value),
IdleTimeout = int.Parse(spinIdleTimeout.Text) * 1000,
};
if (_useWindowsPerformanceCounters)
{
stpStartInfo.PerformanceCounterInstanceName = "WIG Test SmartThreadPool";
}
else
{
stpStartInfo.EnableLocalPerformanceCounters = true;
}
_smartThreadPool = new SmartThreadPool(stpStartInfo);
_wig1 = _smartThreadPool.CreateWorkItemsGroup((int)spinCon1.Value);
_wig2 = _smartThreadPool.CreateWorkItemsGroup((int)spinCon2.Value);
_wig3 = _smartThreadPool.CreateWorkItemsGroup((int)spinCon3.Value);
spinCon1.Tag = _wig1;
spinCon2.Tag = _wig2;
spinCon3.Tag = _wig3;
spinCon6.Tag = _smartThreadPool;
comboWIPriority1.SelectedIndex = 1;
comboWIPriority2.SelectedIndex = 1;
comboWIPriority3.SelectedIndex = 1;
comboWIPriority6.SelectedIndex = 1;
_wigEntries = new WigEntry[]
{
new WigEntry(_wig1, queueUsageControl1, lblStatus1),
new WigEntry(_wig2, queueUsageControl2, lblStatus2),
new WigEntry(_wig3, queueUsageControl3, lblStatus3),
};
for (int i = 0; i < _lastIndex.Length; i++)
{
_lastIndex[i] = 1;
}
}
/// <summary>
/// Initialize the callback holding object.
/// </summary>
/// <param name="workItemsGroup">The workItemGroup of the workitem</param>
/// <param name="workItemInfo">The WorkItemInfo of te workitem</param>
/// <param name="callback">Callback delegate for the callback.</param>
/// <param name="state">State with which to call the callback delegate.</param>
///
/// We assume that the WorkItem object is created within the thread
/// that meant to run the callback
public WorkItem(
IWorkItemsGroup workItemsGroup,
WorkItemInfo workItemInfo,
WorkItemCallback callback,
object state)
{
_workItemsGroup = workItemsGroup;
_workItemInfo = workItemInfo;
#if !(_WINDOWS_CE) && !(_SILVERLIGHT) && !(WINDOWS_PHONE)
if (_workItemInfo.UseCallerCallContext || _workItemInfo.UseCallerHttpContext)
{
_callerContext = CallerThreadContext.Capture(_workItemInfo.UseCallerCallContext, _workItemInfo.UseCallerHttpContext);
}
#endif
_callback = callback;
_state = state;
_workItemResult = new WorkItemResult(this);
Initialize();
}
private void ValidateWorkItemsGroupWaitForIdleImpl(IWorkItemsGroup workItemsGroup, WorkItem workItem)
{
if ((null != workItemsGroup) &&
(null != workItem) &&
workItem.WasQueuedBy(workItemsGroup))
{
throw new NotSupportedException("WaitForIdle cannot be called from a thread on its SmartThreadPool, it will cause may cause a deadlock");
}
}
// Token: 0x060017EE RID: 6126
// RVA: 0x00014AD5 File Offset: 0x00012CD5
internal void RegisterWorkItemsGroup(IWorkItemsGroup iworkItemsGroup_0)
{
this._workItemsGroups[iworkItemsGroup_0] = iworkItemsGroup_0;
}
// Token: 0x060017EF RID: 6127
// RVA: 0x00014AE4 File Offset: 0x00012CE4
internal void UnregisterWorkItemsGroup(IWorkItemsGroup iworkItemsGroup_0)
{
if (this._workItemsGroups.Contains(iworkItemsGroup_0))
{
this._workItemsGroups.Remove(iworkItemsGroup_0);
}
}
/// <summary>
/// Create a new work item
/// </summary>
/// <param name = "wigStartInfo">Work item group start information</param>
/// <param name = "workItemInfo">Work item information</param>
/// <param name = "callback">A callback to execute</param>
/// <param name = "state">
/// The context object of the work item. Used for passing arguments to the work item.
/// </param>
/// <returns>Returns a work item</returns>
public static WorkItem CreateWorkItem(
IWorkItemsGroup workItemsGroup,
WIGStartInfo wigStartInfo,
WorkItemInfo workItemInfo,
WorkItemCallback callback,
object state)
{
ValidateCallback(callback);
ValidateCallback(workItemInfo.PostExecuteWorkItemCallback);
WorkItem workItem = new WorkItem(
workItemsGroup,
new WorkItemInfo(workItemInfo),
callback,
state);
return workItem;
}
internal bool WasQueuedBy(IWorkItemsGroup workItemsGroup)
{
return (workItemsGroup == _workItemsGroup);
}
/// <summary>
/// Create a new work item
/// </summary>
/// <param name = "wigStartInfo">Work item group start information</param>
/// <param name = "callback">A callback to execute</param>
/// <param name = "state">
/// The context object of the work item. Used for passing arguments to the work item.
/// </param>
/// <param name = "postExecuteWorkItemCallback">
/// A delegate to call after the callback completion
/// </param>
/// <param name = "callToPostExecute">Indicates on which cases to call to the post execute callback</param>
/// <param name = "workItemPriority">The work item priority</param>
/// <returns>Returns a work item</returns>
public static WorkItem CreateWorkItem(
IWorkItemsGroup workItemsGroup,
WIGStartInfo wigStartInfo,
WorkItemCallback callback,
object state,
PostExecuteWorkItemCallback postExecuteWorkItemCallback,
CallToPostExecute callToPostExecute,
WorkItemPriority workItemPriority)
{
ValidateCallback(callback);
ValidateCallback(postExecuteWorkItemCallback);
WorkItemInfo workItemInfo = new WorkItemInfo
{
UseCallerCallContext = wigStartInfo.UseCallerCallContext,
UseCallerHttpContext = wigStartInfo.UseCallerHttpContext,
PostExecuteWorkItemCallback = postExecuteWorkItemCallback,
CallToPostExecute = callToPostExecute,
WorkItemPriority = workItemPriority,
DisposeOfStateObjects = wigStartInfo.DisposeOfStateObjects
};
WorkItem workItem = new WorkItem(
workItemsGroup,
workItemInfo,
callback,
state);
return workItem;
}
private void EnqueueWorkItems(ref int startIndex, int count, string text, Color color, WorkItemPriority priority, IWorkItemsGroup wig, int sleepDuration)
{
for (int i = 0; i < count; ++i, ++startIndex)
{
wig.QueueWorkItem(
DoNothing,
new WorkItemState(new QueueUsageControl.QueueUsageEntry(string.Format("{0}{1} ({2})", text, startIndex, priority.ToString().Substring(0,2 )), color), sleepDuration),
priority);
}
_workItemsGenerated += count;
}
private void wig_OnIdle(IWorkItemsGroup workItemsGroup)
{
Debug.WriteLine("WIG is idle");
}
private void UpdateQueueUsageControl(
IWorkItemsGroup wig,
QueueUsageControl queueUsageControl,
Label label)
{
label.Text = wig.IsIdle ? "Idle" : "Working";
object[] states = wig.GetStates();
List<QueueUsageControl.QueueUsageEntry> list = new List<QueueUsageControl.QueueUsageEntry>();
foreach (WorkItemState state in states)
{
if (null != state)
{
list.Add(state.QueueUsageEntry);
}
}
queueUsageControl.SetQueue(list);
}
