public void WaitAllT()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
bool success = true;
IWorkItemResult <int>[] wirs = new IWorkItemResult <int> [5];
for (int i = 0; i < wirs.Length; ++i)
{
wirs[i] = smartThreadPool.QueueWorkItem(new Func <int, int, int>(System.Math.Min), i, i + 1);
}
SmartThreadPool.WaitAll(wirs);
for (int i = 0; i < wirs.Length; ++i)
{
if (!wirs[i].IsCompleted)
{
success = false;
break;
}
int result = wirs[i].GetResult();
if (i != result)
{
success = false;
break;
}
}
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public async Task Execute(IJobExecutionContext context)
{
if (!IsRunning)
{
IsRunning = true;
baseUrl = context.JobDetail.JobDataMap.Get("baseUrl").ToString();
proxyUrl = context.JobDetail.JobDataMap.Get("proxyUrl").ToString();
feedNode = context.JobDetail.JobDataMap.Get("node") as FeedNode;
Logger.GetLogger(baseUrl).Info("start feed job execute");
var task = Task.Factory.StartNew(() =>
{
var feeds = GetFeedJobs(baseUrl, proxyUrl, feedNode);
var compile = new UrlCompile();
var stpStartInfo = new STPStartInfo
{
IdleTimeout = 3000,
MaxWorkerThreads = 8,
MinWorkerThreads = 0
};
var pool = new SmartThreadPool(stpStartInfo);
var waits = new List <IWorkItemResult>();
foreach (var feed in feeds)
{
var addrs = compile.GetResult(feed.Address);
Logger.GetLogger(baseUrl).Info("compile address " + feed.Address + " result " + string.Join(",", addrs));
foreach (var addr in addrs)
{
feed.Address = addr.ToString();
var item = pool.QueueWorkItem((u) =>
{
DoTask(u, true);
}, feed);
waits.Add(item);
}
}
SmartThreadPool.WaitAll(waits.ToArray());
pool.Shutdown(true, 1000);
pool.Dispose();
pool = null;
waits.Clear();
});
await task;
IsRunning = false;
Logger.GetLogger(baseUrl).Info("end feed job execute");
}
}
private void BtnOpen_Click(object sender, EventArgs e)
{
btnOpen.Enabled = false;
openDir.SelectedPath = appPath;
if (openDir.ShowDialog() == DialogResult.OK)
{
appPath = openDir.SelectedPath;
OnLoad();
OnShown();
var works = waitQueue.ToArray();
waitQueue.Add(pool.QueueWorkItem(() =>
{
try
{
if (works != null && works.Length > 0)
{
SmartThreadPool.WaitAll(works);
waitQueue.RemoveAll(q => works.Contains(q));
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ex.StackTrace);
}
Invoke(new invProcess(AddProcess), new object[] { 100 });
}));
single.QueueWorkItem(() => Invoke(new invClear(ChangeStatus)));
}
btnOpen.Enabled = true;
}
public void WaitAllWithEmptyArray()
{
IWorkItemResult [] wirs = new IWorkItemResult[0];
bool success = SmartThreadPool.WaitAll(wirs);;
Assert.IsTrue(success);
}
public bool Wait(int t)
{
// We use the integer version of WaitAll because the current version of SmartThreadPool has a bug with the
// TimeSpan version. The number of milliseconds in TimeSpan is an int64 so when STP casts it down to an
// int (32-bit) we can end up with bad values. This occurs on Windows though curiously not on Mono 2.10.8
// (or very likely other versions of Mono at least up until 3.0.3).
return(SmartThreadPool.WaitAll(new IWorkItemResult[] { wr }, t, false));
}
public static void UpdatePrice()
{
var datenow = DateTime.Now;
var lastupdated = WayBillController.GetLastUpdateTime(path);
var shippinglist = FreightController.GetShippingMethodList(DateTime.Parse(lastupdated));
if (shippinglist != null && shippinglist.List != null && shippinglist.List.Count > 0)
{
Log.Info("开始同步运输方式!");
shippinglist.List.ForEach(p => WayBillController.SynchronousShippingMethod(p.ShippingMethodId, p.ShippingMethodTypeId, p.Enabled));
Log.Info("完成同步运输方式!");
}
var list = WayBillController.GetUpdatePriceWayBillList(lastupdated);
//更新最够更新时间
LogTime.WriteFile(path, datenow.ToString("yyyy-MM-dd HH:mm:ss"));
Log.Info(datenow.ToString("yyyy-MM-dd HH:mm:ss"));
if (list == null || list.Count <= 0)
{
return;
}
if (ismultithreading.ToLowerInvariant() == "no")
{
//单线程
foreach (var venderPackageModel in list)
{
if (!WayBillController.UpdatePriceWayBill(FreightController.PostVenderPrice(venderPackageModel),
venderPackageModel.WayBillNumber))
{
Log.Error(string.Format("运单号：{0}更新错误！", venderPackageModel.WayBillNumber));
}
}
}
else if (ismultithreading.ToLowerInvariant() == "yes")
{
//多线程
if (minThreads > maxThreads)
{
maxThreads = minThreads;
}
var threadPool = new SmartThreadPool {
MaxThreads = maxThreads < 1?1:maxThreads, MinThreads = minThreads < 1?1:minThreads
};
var pendingWorkItems = new IWorkItemResult[list.Count];
for (int i = 0; i < list.Count; i++)
{
pendingWorkItems[i] = threadPool.QueueWorkItem(new WorkItemCallback(MUpdatePrice), list[i]);
}
if (SmartThreadPool.WaitAll(pendingWorkItems))
{
threadPool.Shutdown();
}
}
}
private void RunConversionPool()
{
results.Clear();
convertPool = SetupSmartThreadPool(settings.ConversionPoolThreads);
addConversionsToQueue();
convertPool.Start();
bool converted = SmartThreadPool.WaitAll(results.ToArray());
convertPool.Shutdown();
WriteStatus("conversion Pool completed, success = " + converted.ToString());
}
public static void Run(SmartThread.Action task1)
{
SmartThreadPool st = new SmartThreadPool();
IWorkItemResult t1 = st.QueueWorkItem(() =>
{
task1();
});
bool success = SmartThreadPool.WaitAll(new IWorkItemResult[] { t1 });
//if (success) result1 = (int)wir1.Result;
st.Shutdown();
}
public async Task Execute(IJobExecutionContext context)
{
if (!IsRunning)
{
IsRunning = true;
OnStart(context);
var task = Task.Factory.StartNew(() =>
{
var requests = GetRequests();
var stpStartInfo = new STPStartInfo
{
IdleTimeout = 3000,
MaxWorkerThreads = MaxWorkerThreads,
MinWorkerThreads = 0
};
var pool = new SmartThreadPool(stpStartInfo);
var waits = new List <IWorkItemResult>();
foreach (var fr in requests)
{
if (fr.Request.Headers.Count(m => m.Name == "Referer") == 0)
{
fr.Request.Headers.Add(new WebHeader("Referer", fr.Request.Uri.AbsoluteUri));
}
var item = pool.QueueWorkItem((u) =>
{
var response = DoTask((Request)u.Request);
Save(u, response);
}, fr);
waits.Add(item);
}
SmartThreadPool.WaitAll(waits.ToArray());
pool.Shutdown(true, 1000);
pool.Dispose();
pool = null;
waits.Clear();
});
await task;
IsRunning = false;
}
}
private void BtnSave_Click(object sender, EventArgs e)
{
btnSave.Enabled = false;
var save = new StringBuilder($"\r\n==当前文件夹/前缀缩写:{shorten}\r\n目录列表:\r\n");
var wait = waitQueue.ToArray();
waitQueue.Add(single.QueueWorkItem(() =>
{
try
{
SmartThreadPool.WaitAll(wait);
waitQueue.RemoveAll(q => wait.Contains(q));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + ex.StackTrace);
}
var p = Parallel.For(0, clistDirs.Items.Count, i => save.Append(clistDirs.Items[i] + "\r\n"));
while (!p.IsCompleted)
{
Thread.Sleep(1000);
}
save.Append("\r\n文件列表:\r\n");
p = Parallel.For(0, listBrowse.Items.Count, i => save.Append(listBrowse.Items[i] + "\r\n"));
while (!p.IsCompleted)
{
Thread.Sleep(1000);
}
save.Append("\r\n缺失列表:\r\n");
p = Parallel.For(0, listLost.Items.Count, i => save.Append(listLost.Items[i] + "\r\n"));
while (!p.IsCompleted)
{
Thread.Sleep(1000);
}
save.Append("\r\n报告:\r\n");
save.Append(lblStatus.Text);
var writer = saveFileFullName.AppendText();
var reader = new StringReader(save.ToString() + $"\r\n{DateTime.Now}完成==\r\n");
int len = 4096;
char[] strToWrite = new char[len];
while (0 < (len = reader.Read(strToWrite, 0, 4096)))
{
writer.Write(strToWrite, 0, len);
}
writer.Close();
reader.Close();
save.Clear();
}));
btnSave.Enabled = true;
}
private void RunDownloadPool(WorkType work)
{
//Setup downloadPool
downloadPool = SetupSmartThreadPool(settings.DownloadPoolThreads);
//Select the items to add to the queue
addDownloadTasksToQueue(work);
downloadPool.Start();
bool success = SmartThreadPool.WaitAll(results.ToArray());
downloadPool.Shutdown();
WriteStatus("Download Pool Completed, succeeded = " + success.ToString());
}
public async Task Execute(IJobExecutionContext context)
{
if (!IsRunning)
{
IsRunning = true;
baseUrl = context.JobDetail.JobDataMap.Get("baseUrl").ToString();
try
{
MoveDelayFeed();
var task = Task.Factory.StartNew(() =>
{
var files = Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory + @"snapshot");
var stpStartInfo = new STPStartInfo
{
IdleTimeout = 3000,
MaxWorkerThreads = 8,
MinWorkerThreads = 0
};
var pool = new SmartThreadPool(stpStartInfo);
var waits = new List <IWorkItemResult>();
foreach (var file in files)
{
var item = pool.QueueWorkItem((fileName) =>
{
DoTask(fileName);
}, file);
waits.Add(item);
}
SmartThreadPool.WaitAll(waits.ToArray());
pool.Shutdown(true, 1000);
pool.Dispose();
pool = null;
waits.Clear();
});
await task;
}
catch { }
IsRunning = false;
}
}
public async Task Execute(IJobExecutionContext context)
{
if (!IsRunning)
{
IsRunning = true;
var task = Task.Factory.StartNew(() =>
{
var proxyUrl = context.JobDetail.JobDataMap.Get("proxyUrl").ToString();
var node = context.JobDetail.JobDataMap.Get("node") as FeedNode;
var feeds = GetFeedJobs(proxyUrl, node);
var stpStartInfo = new STPStartInfo
{
IdleTimeout = 3000,
MaxWorkerThreads = 8,
MinWorkerThreads = 0
};
var pool = new SmartThreadPool(stpStartInfo);
var waits = new List <IWorkItemResult>();
foreach (var feed in feeds)
{
var item = pool.QueueWorkItem((u) =>
{
DoTask(u, true);
}, feed);
waits.Add(item);
}
SmartThreadPool.WaitAll(waits.ToArray());
pool.Shutdown(true, 1000);
pool.Dispose();
pool = null;
waits.Clear();
});
await task;
IsRunning = false;
}
}
public void WaitAllWithTimeoutFailure()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemResult [] wirs = new IWorkItemResult[5];
for (int i = 0; i < wirs.Length; ++i)
{
wirs[i] =
smartThreadPool.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
}
bool timeout = !SmartThreadPool.WaitAll(wirs, 10, true);
bool success = timeout;
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public async Task Execute(IJobExecutionContext context)
{
if (!IsRunning)
{
IsRunning = true;
OnStart(context);
var task = Task.Factory.StartNew(() =>
{
var snapshots = GetSnapshot();
var stpStartInfo = new STPStartInfo
{
IdleTimeout = 3000,
MaxWorkerThreads = MaxWorkerThreads,
MinWorkerThreads = 0
};
var pool = new SmartThreadPool(stpStartInfo);
var waits = new List <IWorkItemResult>();
foreach (var snapshot in snapshots)
{
var item = pool.QueueWorkItem((u) =>
{
DoTask(u);
}, snapshot);
waits.Add(item);
}
SmartThreadPool.WaitAll(waits.ToArray());
pool.Shutdown(true, 1000);
pool.Dispose();
pool = null;
waits.Clear();
});
await task;
IsRunning = false;
}
}
public static void UpdatePrice()
{
var list = WayBillController.GetUpdatePriceWayBillList();
if (list == null || list.Count <= 0)
{
return;
}
if (ismultithreading.ToLowerInvariant() == "no")
{
//单线程
foreach (var model in list)
{
if (!WayBillController.UpdatePriceWayBill(FreightController.GetFreightPrice(model),
model.WayBillNumber, model.ReceivingExpenseID))
{
Log.Error(string.Format("运单号：{0}更新错误！", model.WayBillNumber));
}
}
}
else if (ismultithreading.ToLowerInvariant() == "yes")
{
//多线程
if (minThreads > maxThreads)
{
maxThreads = minThreads;
}
var threadPool = new SmartThreadPool {
MaxThreads = maxThreads < 1 ? 1 : maxThreads, MinThreads = minThreads < 1 ? 1 : minThreads
};
var pendingWorkItems = new IWorkItemResult[list.Count];
for (int i = 0; i < list.Count; i++)
{
pendingWorkItems[i] = threadPool.QueueWorkItem(new WorkItemCallback(MUpdatePrice), list[i]);
}
if (SmartThreadPool.WaitAll(pendingWorkItems))
{
threadPool.Shutdown();
}
}
}
private void RunUpdateFeedPool()
{
results.Clear();
feedPool = SetupSmartThreadPool(settings.UpdateFeedPoolThreads);
//Add Items
addFeedsToQueue();
feedPool.Start();
SmartThreadPool.WaitAll(results.ToArray());
feedList.Clear();
foreach (var r in results)
{
feedList.Add((InnerTubeFeed)r.Result);
}
feedPool.Shutdown();
WriteStatus("Update Feeds complete");
}
public void WaitAllWithTimeoutSuccess()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
IWorkItemResult [] wirs = new IWorkItemResult[5];
for (int i = 0; i < wirs.Length; ++i)
{
wirs[i] =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
}
bool timeout = !SmartThreadPool.WaitAll(wirs, 1500, true);
bool success = !timeout;
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
/// <summary>
/// Break |list| into slices of at least |minChunkSize| and schedule them on a thread pool.
/// |action| is executed on each slice.
/// </summary>
public static void ParallelDo <T>(this IList <T> list, Action <IEnumerable <T> > action,
int minChunkSize = DefaultMinChunkSize,
SmartThreadPool threadPool = null)
{
threadPool = threadPool ?? DefaultSmartThreadPool;
const int maxHandles = 64; // Maximum for WaitHandle
var count = list.Count();
if (count == 0)
{
return;
}
// WaitAll() does not support waiting for multiple handles on STA threads.
if (count < minChunkSize * 2)
{
action(list);
return;
}
var parallelism = Math.Min(maxHandles, Math.Max(1, count / minChunkSize));
var effectiveChunkSize = count / parallelism;
var items = new IWorkItemResult[parallelism];
for (var offset = 0; offset < parallelism; offset++)
{
var start = effectiveChunkSize * offset;
var chunk = list.Skip(start).Take(offset == parallelism - 1 ? count - start : effectiveChunkSize);
items[offset] = threadPool.QueueWorkItem(() => action(chunk));
}
try
{
SmartThreadPool.WaitAll(items);
}
catch (ThreadInterruptedException ex)
{
foreach (var item in items)
{
item.Cancel();
}
throw;
}
}
/// <summary>
/// 程序入口 朱旺 2018.4.23 add
/// </summary>
public void SyncData()
{
int Count = GetCount();
if (Count != 0)
{
int Page = Count % Row == 0 ? Count / Row : Count / Row + 1; //第一步计算该开多少个线程
DeleteTable(); //第二步清空表数据
//第三步多线程执行方法
using (SmartThreadPool smartThreadPool = new SmartThreadPool())
{
List <IWorkItemResult> wirs = new List <IWorkItemResult>();
for (int i = 1; i <= Page; i++)
{
IWorkItemResult wir = smartThreadPool.QueueWorkItem(new WorkItemCallback(@delegate), i);
wirs.Add(wir);
}
SmartThreadPool.WaitAll(wirs.ToArray());
}
}
}
public void ThrottleTest()
{
var throttle = new ConcurrencyThrottle {
MaxValue = 5, Enabled = true
};
var maxReg = new MaxRegister();
var threadPool = new SmartThreadPool();
var state = new DoWorkState {
Throttle = throttle, MaxRegister = maxReg
};
var workItemResults = new List <IWaitableResult>();
for (var i = 0; i < 100; i++)
{
workItemResults.Add(threadPool.QueueWorkItem(DoWork, state));
}
SmartThreadPool.WaitAll(workItemResults.ToArray());
Assert.IsTrue(maxReg.MaxValue <= 5);
}
public void WaitAll()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemsGroup workItemsGroup = smartThreadPool.CreateWorkItemsGroup(int.MaxValue);
bool success = true;
IWorkItemResult [] wirs = new IWorkItemResult[5];
for (int i = 0; i < wirs.Length; ++i)
{
wirs[i] =
workItemsGroup.QueueWorkItem(new WorkItemCallback(this.DoSomeWork), null);
}
SmartThreadPool.WaitAll(wirs);
for (int i = 0; i < wirs.Length; ++i)
{
if (!wirs[i].IsCompleted)
{
success = false;
break;
}
else
{
int result = (int)wirs[i].GetResult();
if (1 != result)
{
success = false;
break;
}
}
}
smartThreadPool.Shutdown();
Assert.IsTrue(success);
}
public static void TestMultipleSerialization()
{
//MessageSharkSerializer.Build();
var count = 10000;
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemResult[] tasks = new IWorkItemResult[count];
for (var i = 0; i < count; i++)
{
SmartThreadPool st = new SmartThreadPool();
tasks[i] = st.QueueWorkItem(() =>
{
var data = new Message()
{
ID = 10, CreateDate = DateTime.Now, Data = "This is a test"
};
var buffer666 = MessageSharkSerializer.Serialize(data);
//threads.Add(Thread.CurrentThread.ManagedThreadId);
});
}
bool success = SmartThreadPool.WaitAll(tasks);
//if (success) result1 = (int)wir1.Result;
smartThreadPool.Shutdown();
//var tasks = new Task[count];
////var threads = new ConcurrentBag<int>();
//for (var i = 0; i < count; i++)
//{
// tasks[i] = Task.Factory.StartNew(() =>
// {
// var data = new Message() { ID = 10, CreateDate = DateTime.Now, Data = "This is a test" };
// var buffer = MessageSharkSerializer.Serialize(data);
// //threads.Add(Thread.CurrentThread.ManagedThreadId);
// }).ContinueWith(t => Handle(t), TaskContinuationOptions.OnlyOnFaulted)
// .ContinueWith(_ => { });
//}
//Task.WaitAll(tasks);
}
private void Update()
{
if (!_sema.WaitOne(10))
{
return;
}
var stp = StaticInstance.ThreadPool;
//stp.MaxThreads = (int) _setti.NumFetchThreads;
var results = new List <IWaitableResult>();
foreach (FavShowData t in _setti.TvShows)
{
results.Add(stp.QueueWorkItem(data => data.Fetch(), t, true, ThreadPriority.AboveNormal)); //schedule update of show (executed paralell)
}
//wait for completion
stp.QueueWorkItem(() =>
{
SmartThreadPool.WaitAll(results.ToArray());
_sema.Release();
var updates = _setti.TvShows.Where(show => show.NewEpisodes && !show.Notified).ToList();
if (updates.Count > 0)
{
updates.ForEach(show => show.Notified = true);
if (_setti.ShowNotifications)
{
Dispatcher.Invoke(() =>
{
var n = new NotificationBalloon(updates);
n.ShowViewClicked += on_ShowViewClicked;
NotifyIcon.ShowCustomBalloon(n, PopupAnimation.Slide, _setti.NotificationTimeout <= 0 ? (int?)null : _setti.NotificationTimeout);
});
}
}
}, true, ThreadPriority.AboveNormal);
}
public void DoWork()
{
SmartThreadPool smartThreadPool = new SmartThreadPool();
IWorkItemResult wir1 =
smartThreadPool.QueueWorkItem(new
WorkItemCallback(this.DoSomeWork1), null);
IWorkItemResult wir2 =
smartThreadPool.QueueWorkItem(new
WorkItemCallback(this.DoSomeWork2), null);
bool success = SmartThreadPool.WaitAll(new IWorkItemResult [] { wir1, wir2 });
if (success)
{
int result1 = (int)wir1.Result;
int result2 = (int)wir2.Result;
}
smartThreadPool.Shutdown();
}
private void PingButton_OnClick_invoke()
{
// PingButton.IsEnabled = false;
this.Dispatcher.Invoke(() => PingButton.IsEnabled = false);
threadPool.Cancel();
// PingDataList.Clear();
this.Dispatcher.Invoke(() => PingDataList.Clear());
var select_str = this.Dispatcher.Invoke(() => ComboDomainBox.Text);
var htmldata = HttpHelper.GetHtmlTask($"http://ping.chinaz.com/", select_str, new { host = select_str, linetype = "电信,多线,联通,移动,海外" });
if (String.IsNullOrWhiteSpace(htmldata.Encode))
{
this.Dispatcher.Invoke(() => PingButton.IsEnabled = true);
return;
}
var templist = new ObservableCollection <PingData>();
foreach (var guidLocalKey in htmldata.GuidLocal.Keys)
{
templist.Add(new PingData(guidLocalKey, htmldata.GuidLocal[guidLocalKey], select_str));
}
this.Dispatcher.Invoke(() => {
PingDataList = templist;
PingDataGrid.ItemsSource = PingDataList;
});
List <IWorkItemResult> threadResults = new List <IWorkItemResult>();
foreach (var guidLocalKey in htmldata.GuidLocal.Keys)
{
threadResults.Add(threadPool.QueueWorkItem(new WorkItemCallback(UpdateData), new UpdateDataParams(guidLocalKey, select_str, htmldata.Encode)));
}
SmartThreadPool.WaitAll(threadResults.ToArray());
Task.Factory.StartNew(LocalPing);
this.Dispatcher.Invoke(() => PingButton.IsEnabled = true);
// PingButton.IsEnabled = true;
}
public void ComputeFitnesses()
{
int numberOfThreadsX = System.Environment.ProcessorCount;
if (numberOfThreadsX == 1)
{
// Single-threaded implementation
foreach (Individual i in members)
{
double[] fitness = i.Fitness;
}
}
else
{
// Multithreaded implementation
using (SmartThreadPool pool = new SmartThreadPool(1000, numberOfThreadsX, numberOfThreadsX))
{
IWorkItemResult[] results = new IWorkItemResult[members.Count];
for (int i = 0; i < members.Count; ++i)
{
WorkItemCallback workItem = new WorkItemCallback(this.ComputeFitness);
results[i] = pool.QueueWorkItem(workItem, members[i]);
}
SmartThreadPool.WaitAll(results);
}
}
ComputeParetoRanking();
// TODO: Ideally this code would be moved elsewhere
// Sort in descending Pareto Rank order - we want the best
// individuals at the front of the container
members.Sort(delegate(Individual lhs, Individual rhs)
{
return(rhs.ParetoRank.CompareTo(lhs.ParetoRank));
});
}
public bool Wait(TimeSpan t)
{
return(SmartThreadPool.WaitAll(new IWorkItemResult[] { wr }, t, false));
}
/// <summary>
/// Runs each installer on every VM in specified by config file
/// </summary>
/// <returns>List of all the results from the RemoteInstalls</returns>
public List <ResultsGroup> Run()
{
STPStartInfo poolStartInfo = new STPStartInfo();
List <IWorkItemResult <IList <IList <ResultsGroup> > > > poolResults = new List <IWorkItemResult <IList <IList <ResultsGroup> > > >();
// build parallelizable tasks
ParallelizableRemoteInstallDriverTaskCollections ptasks = new ParallelizableRemoteInstallDriverTaskCollections();
if (_configuration.VirtualMachines.Count == 0)
{
throw new InvalidConfigurationException("Missing virtual machines in configuration.");
}
// build the sequence that is going to be run
foreach (VirtualMachineConfig vm in _configuration.VirtualMachines)
{
DriverTaskCollection tasks = new DriverTaskCollection();
if (vm.Snapshots.Count == 0)
{
throw new InvalidConfigurationException(string.Format("Missing snapshots in {0}. Define a 'current' snapshot with <snapshot name='*' />.",
vm.Name));
}
switch (_configuration.Installers.Sequence)
{
case InstallersSequence.alternate:
tasks.Add(new DriverTasks.DriverTask_Alternate(_configuration,
_logpath, _simulationOnly, vm, _configuration.Installers, true, true));
break;
case InstallersSequence.install:
tasks.Add(new DriverTasks.DriverTask_Alternate(_configuration,
_logpath, _simulationOnly, vm, _configuration.Installers, true, false));
break;
case InstallersSequence.uninstall:
tasks.Add(new DriverTasks.DriverTask_Alternate(_configuration,
_logpath, _simulationOnly, vm, _configuration.Installers, false, true));
break;
case InstallersSequence.fifo:
tasks.Add(new DriverTasks.DriverTask_Fifo(_configuration,
_logpath, _simulationOnly, vm, _configuration.Installers));
break;
case InstallersSequence.lifo:
tasks.Add(new DriverTasks.DriverTask_Lifo(_configuration,
_logpath, _simulationOnly, vm, _configuration.Installers));
break;
case InstallersSequence.clean:
default:
tasks.Add(new DriverTasks.DriverTask_Clean(_configuration,
_logpath, _simulationOnly, vm, _configuration.Installers));
break;
}
ptasks.Add(tasks);
}
// the number of threads in the pipeline is either user-defined
// or the number of virtual machines (default)
if (_pipelineCount > 0)
{
poolStartInfo.MaxWorkerThreads = _pipelineCount;
}
else
{
poolStartInfo.MaxWorkerThreads = ptasks.Count;
}
if (ptasks.Count == 0)
{
throw new InvalidConfigurationException("Number of tasks cannot be zero.");
}
ConsoleOutput.WriteLine(string.Format("Starting {0} parallel installation(s) ({1} max) ...",
poolStartInfo.MaxWorkerThreads, ptasks.Count));
SmartThreadPool pool = new SmartThreadPool(poolStartInfo);
ConsoleOutput.ShowThreadID = (poolStartInfo.MaxWorkerThreads > 1);
foreach (DriverTaskCollections tasks in ptasks)
{
poolResults.Add(pool.QueueWorkItem <DriverTaskCollections, IList <IList <ResultsGroup> > >(
RunTasks, tasks));
}
// wait for the pool to finish all the work
SmartThreadPool.WaitAll(poolResults.ToArray());
// collect results
List <ResultsGroup> groups = new List <ResultsGroup>();
foreach (IWorkItemResult <IList <IList <ResultsGroup> > > poolResult in poolResults)
{
foreach (IList <ResultsGroup> poolResultItem in poolResult.GetResult())
{
groups.AddRange(poolResultItem);
}
}
ConsoleOutput.WriteLine("Finished installation(s) with {0} result(s)",
groups.Count);
return(groups);
}
private void CheckFiles(object checkedObject = null, bool isChecked = false)
{
cyborgCheck = false;
var clist = new ArrayList(clistDirs.CheckedItems);
var setStatus = new invClear(ChangeStatus);
if (checkedObject != null && !isChecked && !clist.Contains(checkedObject))
{
clist.Add(checkedObject);
}
else
{
clist.Remove(checkedObject);
}
var waitFor = waitQueue.ToArray <IWorkItemResult>();
var browseClear = new invClear(listBrowse.Items.Clear);
var lostClear = new invClear(listLost.Items.Clear);
var browseAddRange = new invAddRang(listBrowse.Items.AddRange);
var lostAddRange = new invAddRang(listLost.Items.AddRange);
var maxPb = new invClear(MaxProcess);
var add = new invClear(AddProcess);
Invoke(maxPb);
var work = pool.QueueWorkItem(() =>
{
var browse = new List <FileInfo>();
var lost = new List <string>();
SmartThreadPool.WaitAll(waitFor);
waitQueue.RemoveAll(q => waitFor.Contains <IWorkItemResult>(q));
Parallel.For(0, clist.Count, i =>
{
Invoke(maxPb);
try
{
var item = shorten + clist[i].ToString();
if (cacheBrowse.ContainsKey(item) && cacheLost.ContainsKey(item))
{
browse.AddRange(cacheBrowse[item]);
lost.AddRange(cacheLost[item]);
return;
}
var files = from f in Dirs[item] orderby f.FullName descending select f;
if (files == null || files.Count <FileInfo>() == 0)
{
return;
}
Console.WriteLine($"==>{item.GetType()} {item} {files.Count<FileInfo>()}");
browse.AddRange(files);
var thislLost = CheckContinuous(files.ToArray <FileInfo>());
lost.AddRange(thislLost);
cacheBrowse[item] = files;
cacheLost[item] = thislLost;
}
catch (Exception ex)
{
System.Console.WriteLine(ex.Message + ex.StackTrace);
}
finally
{
Invoke(add);
}
});
Invoke(browseClear);
Invoke(lostClear);
Invoke(browseAddRange, new object[] { Array.ConvertAll <FileInfo, string>(browse.ToArray(), f => GetShorten(f.FullName)) });
Invoke(lostAddRange, new object[] { Array.ConvertAll <string, string>(lost.ToArray(), s => GetShorten(s)) });
single.QueueWorkItem(() => Invoke(setStatus));
Invoke(add);
});
waitQueue.Add(work);
Invoke(new invProcess(AddProcess), new object[] { 100 });
waitQueue.Add(pool.QueueWorkItem(() =>
{
SmartThreadPool.WaitAll(new IWaitableResult[] { work });
Invoke(new invClear(ResetProcess));
single.QueueWorkItem(() => Invoke(setStatus));
//Interaction.MsgBox("查询完成！", MsgBoxStyle.Information);
}));
}