public void Run(StopWatch stopWatch)
{
stopWatch.Start();
CheckPoint point = stopWatch.Mark("Correlated Requests");
CheckPoint responsePoint = stopWatch.Mark("Correlated Responses");
var pool = new ManagedThreadPool<CorrelatedController>(DoWorker, 10, 10);
try
{
for (int index = 0; index < _attempts; index++)
{
var controller = new CorrelatedController(_bus, OnSuccess, OnTimeout);
pool.Enqueue(controller);
}
point.Complete(_attempts);
_finishedEvent.WaitOne(TimeSpan.FromSeconds(60), true);
responsePoint.Complete(_timeouts + _successes);
}
finally
{
pool.Dispose();
}
Console.WriteLine("Attempts: {0}, Succeeded: {1}, Timeouts: {2}", _attempts, _successes, _timeouts);
stopWatch.Stop();
}
/// <summary>
/// 响应计数事件
/// </summary>
/// <param name="callArgs"></param>
private void NotifyEventArgs(CallEventArgs callArgs)
{
//调用计数
ManagedThreadPool.QueueUserWorkItem(state =>
{
try
{
var arr = state as ArrayList;
var statusService = arr[0] as ServerStatusService;
var eventArgs = arr[1] as CallEventArgs;
//调用计数服务
statusService.Counter(eventArgs);
//响应消息
MessageCenter.Instance.Notify(eventArgs);
}
catch (Exception ex)
{
//TODO
}
}, new ArrayList {
status, callArgs
});
}
///<summary>
/// 执行计划任务
///</summary>
public static void Execute()
{
Config.Event[] simpleItems = WshelperConfigs.GetConfig().ScheduledEvents;
List <Event> list = new List <Event>();
foreach (Config.Event newEvent in simpleItems)
{
if (!newEvent.Enabled)
{
continue;
}
Event e = new Event();
e.Key = newEvent.Key;
e.ScheduleType = newEvent.ScheduleType;
list.Add(e);
}
Event[] items = list.ToArray();
Event item = null;
for (int i = 0; i < items.Length; i++)
{
item = items[i];
//if (item.ShouldExecute)
//{
// item.UpdateTime();
IEvent e = item.IEventInstance;
ManagedThreadPool.QueueUserWorkItem(e.Execute);
//}
}
}
/// <summary>Adds a new x, y data pair to continuous data set.</summary>
/// <param name="x">New x-axis value.</param>
/// <param name="y">New y-axis value.</param>
public void Calculate(double x, double y)
{
lock (m_xValues)
{
// Adds latest values to regression data set.
m_xValues.Add(x);
m_yValues.Add(y);
// Keeps a constant number of points by removing them from the left.
while (m_xValues.Count > m_pointCount)
{
m_xValues.RemoveAt(0);
}
while (m_yValues.Count > m_pointCount)
{
m_yValues.RemoveAt(0);
}
}
if (m_xValues.Count >= m_pointCount && !m_calculating)
{
// Performs curve fit calculation on seperate thread, since it could be time consuming.
#if ThreadTracking
ManagedThread thread = ManagedThreadPool.QueueUserWorkItem(PerformCalculation);
thread.Name = "TVA.Math.RealTimeSlope.PerformCalculation()";
#else
ThreadPool.QueueUserWorkItem(PerformCalculation);
#endif
}
}
public void Run(StopWatch stopWatch)
{
stopWatch.Start();
CheckPoint point = stopWatch.Mark("Correlated Requests");
CheckPoint responsePoint = stopWatch.Mark("Correlated Responses");
var pool = new ManagedThreadPool <CorrelatedController>(DoWorker, 10, 10);
try
{
for (int index = 0; index < _attempts; index++)
{
var controller = new CorrelatedController(_bus, OnSuccess, OnTimeout);
pool.Enqueue(controller);
}
point.Complete(_attempts);
_finishedEvent.WaitOne(TimeSpan.FromSeconds(60), true);
responsePoint.Complete(_timeouts + _successes);
}
finally
{
pool.Dispose();
}
Console.WriteLine("Attempts: {0}, Succeeded: {1}, Timeouts: {2}", _attempts, _successes, _timeouts);
stopWatch.Stop();
}
/// <summary>
/// 对页面进行更新
/// </summary>
public void Update(TimeSpan timeSpan)
{
ManagedThreadPool.QueueUserWorkItem(state =>
{
TimeSpan span = (TimeSpan)state;
Thread.Sleep(span);
(this as IUpdateItem).Update(DateTime.MaxValue);
}, timeSpan);
}
/// <summary>
/// When a connection is made, get a network stream and start the worker thread.
/// The worker thread uses the managed thread pool, which is safe for handling
/// work that takes a lot of time.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
protected void OnConnected(object sender, TcpServerEventArgs e)
{
ConnectionState cs = e.ConnectionState;
NetworkStream ns = new NetworkStream(cs.Connection, true);
ns.ReadTimeout = readTimeout;
ns.WriteTimeout = writeTimeout;
NetworkStreamConnection conn = new NetworkStreamConnection(ns, cs);
ManagedThreadPool.QueueUserWorkItem(ConnectionProcess, conn);
}
private bool BakExport(string sourceDir, string targetDir)
{
try {
ManagedThreadPool.QueueUserWorkItem((o) => CopyDir(sourceDir, targetDir));
return(true);
} catch (Exception ex) {
Message.Info(string.Format("message:{0},StackTrace:{1}", ex.Message, ex.StackTrace));
return(false);
}
}
/// <summary>
/// 执行单个任务
/// </summary>
/// <param name="task"></param>
private static void ExecuteTask(TaskBase task)
{
//设置最后一次执行时间
task.LastExecuteTime = DateTime.Now;
RecordExecuteTime(task.Type, DateTime.Now);
//Log4Helper.Info("task:" + task.TaskName + ",type:" + task.Type + ",time:" + DateTime.Now.ToString());
ManagedThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(task.Execute));
// task.Execute(null);
}
public override void WriteComplete()
{
//替换内容
string content = ReplaceContext(pageContent.ToString());
string path = HttpContext.Current.Request.Url.PathAndQuery;
//启动生成线程
ManagedThreadPool.QueueUserWorkItem(WriteFile, new ArrayList {
content, path
});
}
public static void Execute()
{
Hyt.Model.Common.Event[] simpleItems = Config.Config.Instance.GetScheduleConfig().Events;
//Event[] items;
if (items == null)
{
List <Event> list = new List <Event>();
var allDealer = Hyt.BLL.Stores.StoresBo.Instance.GetAllStores();
foreach (var d in allDealer)
{
if (string.IsNullOrWhiteSpace(d.AppID) || string.IsNullOrWhiteSpace(d.AppSecret))
{
continue;
}
foreach (Hyt.Model.Common.Event newEvent in simpleItems)
{
if (!newEvent.Enabled)
{
continue;
}
Event e = new Event();
e.Key = newEvent.Key;
e.Minutes = newEvent.Minutes;
e.ScheduleType = newEvent.ScheduleType;
e.TimeOfDay = newEvent.TimeOfDay;
e.DealerSysNo = d.SysNo;
list.Add(e);
}
}
items = list.ToArray();
}
Event item = null;
if (items != null)
{
for (int i = 0; i < items.Length; i++)
{
item = items[i];
if (item.ShouldExecute)
{
item.UpdateTime();
IEvent e = item.IEventInstance;
ManagedThreadPool.QueueUserWorkItem(new WaitCallback(e.Execute), item.DealerSysNo);
}
}
}
}
public static void SendPings(Post post, string pingUrls)
{
// Split ping urls into string array
string[] pingUrlsArray = pingUrls.Split('\n');
// Gather information to pass to ping service(s)
string name = SiteSettings.Get().Title;
string url = post.Category.IsUncategorized ? new Macros().FullUrl(new Urls().Home) : new Macros().FullUrl(post.Category.Url);
string feedUrl = SiteSettings.Get().ExternalFeedUrl ?? new Macros().FullUrl(VirtualPathUtility.ToAbsolute("~/feed/"));
XmlRpcPings pinger = new XmlRpcPings(name, url, feedUrl, pingUrlsArray);
ManagedThreadPool.QueueUserWorkItem(new WaitCallback(pinger.SendPings));
}
/// <summary>
/// 对页面进行更新
/// </summary>
public void Update(TimeSpan timeSpan)
{
ManagedThreadPool.QueueUserWorkItem(state =>
{
ArrayList arr = state as ArrayList;
IStaticPageItem item = (IStaticPageItem)arr[0];
TimeSpan span = (TimeSpan)arr[1];
Thread.Sleep(span);
item.Update();
}, new ArrayList {
this, timeSpan
});
}
public static void Execute()
{
Discuz.Config.Event[] simpleItems = ScheduleConfigs.GetConfig().Events;
Event[] items;
#if NET1
ArrayList list = new ArrayList();
#else
List <Event> list = new List <Event>();
#endif
foreach (Discuz.Config.Event newEvent in simpleItems)
{
if (!newEvent.Enabled)
{
continue;
}
Event e = new Event();
e.Key = newEvent.Key;
e.Minutes = newEvent.Minutes;
e.ScheduleType = newEvent.ScheduleType;
e.TimeOfDay = newEvent.TimeOfDay;
list.Add(e);
}
#if NET1
items = (Event[])list.ToArray(typeof(Event));
#else
items = list.ToArray();
#endif
Event item = null;
if (items != null)
{
for (int i = 0; i < items.Length; i++)
{
item = items[i];
if (item.ShouldExecute)
{
item.UpdateTime();
IEvent e = item.IEventInstance;
ManagedThreadPool.QueueUserWorkItem(new WaitCallback(e.Execute));
}
}
}
}
/// <summary>
/// 输出错误
/// </summary>
/// <param name="error"></param>
public void Write(Exception error)
{
ManagedThreadPool.QueueUserWorkItem(state =>
{
try
{
if (OnError != null)
{
OnError(state as Exception);
}
}
catch (Exception)
{
}
}, error);
}
public void Run(StopWatch watch)
{
_container = new HeavyLoadContainer();
_bus = _container.Resolve <IServiceBus>();
var management = MsmqEndpointManagement.New(_bus.Endpoint.Address.Uri);
management.Purge();
watch.Start();
//BatchServiceComponent component = new BatchServiceComponent();
//_bus.Subscribe(component);
_container.AddComponent <BatchServiceComponent>();
_bus.Subscribe <BatchServiceComponent>();
int batchCount = 100;
CheckPoint publishCheckpoint = watch.Mark("Publishing " + batchCount + " batches");
_threads = new ManagedThreadPool <int>(delegate(int batchLength) { SendBatch(batchLength); }, 10, 10);
for (int i = 0; i < batchCount; i++)
{
_threads.Enqueue(100);
}
for (int i = 0; i < batchCount; i++)
{
bool received = BatchServiceComponent.Received.WaitOne(TimeSpan.FromSeconds(30), true);
if (!received)
{
_log.Error("Something went wrong, we never got a batch completed");
break;
}
}
publishCheckpoint.Complete(batchCount * 100);
watch.Stop();
_log.Info("Test Complete");
}
/// <summary>
/// 输出日志
/// </summary>
/// <param name="log"></param>
/// <param name="type"></param>
public void Write(string log, LogType type)
{
ManagedThreadPool.QueueUserWorkItem(state =>
{
try
{
var arr = state as ArrayList;
if (OnLog != null)
{
OnLog(arr[0] as string, (LogType)arr[1]);
}
}
catch (Exception)
{
}
}, new ArrayList {
log, type
});
}
public MemoryDataProvider([NotNull] string filename, [NotNull] string serializationPath)
{
Assert.ArgumentNotNullOrEmpty(serializationPath, nameof(serializationPath));
Assert.ArgumentNotNullOrEmpty(filename, nameof(filename));
ID = GetId(filename);
Log.Debug("MemoryDataProvider " + ID + " is starting", this);
filename = MainUtil.MapPath(filename);
serializationPath = Path.GetFullPath(Path.Combine(MainUtil.MapPath("/"), serializationPath));
var started = new AutoResetEvent(false);
ManagedThreadPool.QueueUserWorkItem(
a =>
{
lock (this)
{
started.Set();
try
{
using (new SecurityDisabler())
{
lock (string.Intern(filename))
{
if (!LoadFromFile(filename))
{
LoadTree(serializationPath);
SaveToFile(filename);
}
}
}
}
catch (Exception e)
{
Log.Error(e.ToString(), this);
}
}
});
started.WaitOne();
}
protected void gvSchedule_SelectedIndexChanged(object sender, EventArgs e)
{
ILog log = new AppLog();
var logInfo = new LogInfo
{
MethodInstance = MethodBase.GetCurrentMethod(),
ThreadInstance = Thread.CurrentThread
};
try
{
if (gvSchedule.SelectedIndex != -1)
{
var dataKey = gvSchedule.DataKeys[gvSchedule.SelectedIndex];
if (dataKey != null)
{
var key = dataKey.Value.ToString();
var s = Schedule.Single(key);
var instance = s.IScheduleInstance;
ManagedThreadPool.QueueUserWorkItem(instance.Execute);
s.LastCompletedTime = DateTime.Now;
s.Update();
log.Info($"ISchedule Manually: {s.ScheduleType}", logInfo);
}
//this.ClientScript.RegisterClientScriptBlock(typeof(string), "success", string.Format("任务：{0}执行成功');", s.ScheduleType), true);
}
}
catch (Exception ex)
{
log.Error(ex, logInfo);
//this.ClientScript.RegisterClientScriptBlock(typeof(string), "failed", string.Format("alert('{0}');", ex.Message.ToString()), true);
}
}
void DoPushWork(object state)
{
while (true)
{
//启用线程来进行处理
ManagedThreadPool.QueueUserWorkItem(obj =>
{
//响应定时信息
if (statuslist.Count > 0)
{
try
{
var status = GetServerStatus();
MessageCenter.Instance.Notify(status);
}
catch (Exception ex)
{
//TODO
}
}
});
//每分钟进行一次计数
if (counterlist.Count >= 60)
{
counterlist.Reset();
}
else
{
counterlist.Count++;
}
//每秒推送一次
Thread.Sleep(1000);
}
}
/// <summary>
/// 启动静态管理类
/// </summary>
/// <param name="interval">检测间隔时间：单位（秒）</param>
public static void Start(int interval, bool isStartUpdate)
{
if (isRunning)
{
return;
}
isRunning = true;
if (isStartUpdate)
{
//启动一个临时线程生成
ManagedThreadPool.QueueUserWorkItem(state => RunUpdate(DateTime.MaxValue));
}
//启动一个循环线程生成
Thread thread = new Thread(state =>
{
if (state == null)
{
return;
}
var timeSpan = TimeSpan.FromSeconds(Convert.ToInt32(state));
while (true)
{
RunUpdate(DateTime.Now);
//休眠间隔
Thread.Sleep(timeSpan);
}
});
//单位：秒
thread.Start(interval);
}
/// <summary>
/// 执行统计操作
/// </summary>
public void Enqueue()
{
ManagedThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(Process));
}
internal void Listener_ThreadStart(CancellationToken ctToken)
{
try
{
_managedThreadPool = new ManagedThreadPool(_maxWorkerThreads);
_listenerEndedSignal = new ManualResetEvent(false);
_listenerCtSource = CancellationTokenSource.CreateLinkedTokenSource(ctToken);
//_listenerCtSource.Token.Register(() => { /* for debugging purposes. */ });
_callbackThread = new Thread(Callback_ThreadStart);
_callbackThread.IsBackground = false;
_callbackThread.Start();
_tasksExecutedCount = 0;
_listenerStartedSignal.Set();
while (!_listenerCtSource.IsCancellationRequested)
{
try
{
CleanupAndRescheduleTasks();
var taskInfos = ProcessPendingTasks(_managedThreadPool.MaxThreads);
while (ManageTasksLifeTime(taskInfos) > 0)
{
//Allows other threads to execute
Thread.Sleep(1);
}
//Only counts tasks that acquired lock
_tasksExecutedCount += taskInfos.Where(t => t.RealTaskInvokedFlag).Count();
//Release all task locks
foreach (var taskInfo in taskInfos)
{
_taskManager.LockManager.Release(taskInfo.LockInfo);
taskInfo.Dispose();
}
ResumeCallbackThread();
}
catch (ThreadAbortException ex)
{
//Ignores thread abort exceptions and quits
break;
}
catch (Exception ex)
{
LatestListenerException = ex;
ex.LogException();
}
//Sleeps regardless if the previous block threw an exception or not.
Thread.Sleep(_mainLoopWaitTime);
}
}
catch (ThreadAbortException ex)
{
//Ignores thread abort exceptions
}
catch (Exception ex)
{
LatestListenerException = ex;
ex.LogException();
}
finally
{
_listenerStartedSignal = null;
var pool = _managedThreadPool;
if (pool != null)
{
_managedThreadPool = null;
pool.StopPool(waitTillStops: true);
}
var endSignal = _listenerEndedSignal;
if (endSignal != null)
{
_listenerEndedSignal = null;
endSignal.Set();
}
}
}
public static void CheckPost(Post post)
{
LinkParser lp = new LinkParser(SiteSettings.Get().Title, post.Title, new Macros().FullUrl(post.Url), post.Body, post.Excerpt("", "", "", 300), SiteSettings.BaseUrl);
ManagedThreadPool.QueueUserWorkItem(new WaitCallback(lp.CheckPost));
}
public MyWaitCallback(ManagedThreadPool.WaitingCallback wc)
{
Waiting = wc;
}
