public void TestStartOrder() { int maxThreads = 3; string plannedPriorities = "lhhnhhnlhnlhnlllhhhnnnhnhnhhlllhhhnnhn"; string expectedPriorities = "hhhnhhhnhhhnhhhnhhhnhhnnnnnnnlllllllll"; var pool = new FixedThreadPool(maxThreads); StringBuilder actualPriorities = new StringBuilder(); for (int i = 0; i < plannedPriorities.Length; i++) { var task = new TestTask(i.ToString(), ToPriority(plannedPriorities[i]), 100); task.OnStart = (t) => { lock (actualPriorities) actualPriorities.Append(t.Priority.ToString().ToLower()[0]); }; pool.Execute(task, task.Priority); } while (expectedPriorities.Length > actualPriorities.Length) { Thread.Sleep(100); } var actualPrioritiesStr = actualPriorities.ToString(); Assert.AreEqual(expectedPriorities, actualPrioritiesStr); }
public void ExecuteTask_ReturnsTrue() { var pool = new FixedThreadPool(1); Action task = () => Thread.Sleep(1000); Assert.That(pool.Execute(task), Is.EqualTo(true)); }
public void Should_Start_While_Not_Stopped() { var threadPool = new FixedThreadPool(1); var enqueued = threadPool.Execute(MockRepository.GenerateStub <ITask>(), Priority.NORMAL); Assert.True(enqueued); }
public void FixedThreadPool_Execute_TestRun() { var pool = new FixedThreadPool(2); for (int i = 0; i < 100; i++) { pool.Execute(new Task(), (Priority) new Random().Next(3)); } }
public void Should_Not_Start_Task_When_Stopped() { var threadPool = new FixedThreadPool(1); threadPool.Stop(); var enqueued = threadPool.Execute(MockRepository.GenerateStub <ITask>(), Priority.HIGH); Assert.False(enqueued); }
public void ExecuteTask_WhenPoolIsStopped_ReturnsFalse() { var pool = new FixedThreadPool(1); Action task = () => Thread.Sleep(1000); pool.Stop(); Assert.That(pool.IsStopped, Is.EqualTo(true)); Assert.That(pool.Execute(task), Is.EqualTo(false)); }
static void Main(string[] args) { FixedThreadPool pool = new FixedThreadPool(1); pool.Execute(() => { Console.WriteLine("test"); Thread.Sleep(1000); }); Thread.Sleep(10000); Console.ReadLine(); }
private static async Task ExecuteTasks(FixedThreadPool threadPool, int numberOfTasks) { Console.WriteLine($"{numberOfTasks} tasks will be executed."); var random = new Random(); for (var i = 0; i < numberOfTasks; i++) { var priority = (Priority)random.Next((int)Priority.High, (int)Priority.Low + 1); var taskDelayInMilliseconds = random.Next(10, 1000); var task = new ShowTask(taskDelayInMilliseconds); await threadPool.Execute(task, priority); } }
public void Should_Execute_All_Tasks_On_Stop() { var tasks = Enumerable.Range(1, 1000).Select(i => MockRepository.GenerateMock <ITask>()).ToList(); tasks.ForEach(task => task.Expect(t => t.Execute()).WhenCalled(mi => Thread.Sleep(1))); // искусственная задержка var threadPool = new FixedThreadPool(100); tasks.ForEach(task => threadPool.Execute(task, Priority.HIGH)); threadPool.Stop(); tasks.ForEach(task => task.VerifyAllExpectations()); }
/// <summary> /// Загружка выбранных записей. /// </summary> private void Download() { var infos = new[] { teAnalyseUri.Text }; if (!Directory.Exists(teDownloadPath.Text)) { Directory.CreateDirectory(teDownloadPath.Text); } File.WriteAllLines(Path.Combine(teDownloadPath.Text, "_Info.txt"), infos); _threadPool = new FixedThreadPool(Global.Default.varXml.ThreadCount); _threadPool.Finished += ThreadPool_Finished; foreach (var record in _records) { record.ProgressPercentage = 0; } var uri = new Uri(teAnalyseUri.Text); var downloads = _records.Where(item => item.Priority != Priority.None); var log = (int)Math.Log10(_records.Count) + 1; var format = $"D{log}"; foreach (var record in downloads) { var act = new Action(() => DownloadRecord($"{uri.Authority}{record.Reference}", teDownloadPath.Text, $"{record.Index.ToString(format)}. {record.Title}", record)); switch (record.Priority) { case Priority.High: _threadPool.Execute(act, TaskPriorityEx.HIGH); break; case Priority.Normal: _threadPool.Execute(act, TaskPriorityEx.NORMAL); break; case Priority.Low: _threadPool.Execute(act); break; } } }
public void ExecuteTest_TwoPoolNoPriority() { TestConditions result = new TestConditions(); FixedThreadPool pool = new FixedThreadPool(2); DateTime started1 = DateTime.MinValue; DateTime started2 = DateTime.MinValue; DateTime started3 = DateTime.MinValue; DateTime t0 = DateTime.Now; TimeSpan t1, t2, t3; if (!pool.Execute(() => { started1 = DateTime.Now; Console.WriteLine("Task 1"); Thread.Sleep(1000); })) { result.Add(() => false, () => "Void Execute return FALSE unexpectedly"); } if (!pool.Execute(() => { started2 = DateTime.Now; Console.WriteLine("Task 2"); Thread.Sleep(1000); })) { result.Add(() => false, () => "Void Execute return FALSE unexpectedly"); } Thread.Sleep(2500); if (!pool.Execute(() => { started3 = DateTime.Now; Thread.Sleep(100); Console.WriteLine("Task 3"); })) { result.Add(() => false, () => "Void Execute return FALSE unexpectedly"); } Thread.Sleep(500); t1 = started1 - t0; t2 = started2 - t0; t3 = started3 - t0; result.Add(() => 0 <= t1.TotalMilliseconds && t1.TotalMilliseconds < 500, () => string.Format("t1 = {0} != [0; 500)", t1.TotalMilliseconds)); result.Add(() => 0 <= t2.TotalMilliseconds && t2.TotalMilliseconds < 500, () => string.Format("t2 = {0} != [0; 500)", t2.TotalMilliseconds)); result.Add(() => 2500 < t3.TotalMilliseconds && t3.TotalMilliseconds < 3000, () => string.Format("t3 = {0} != (2500; 3000)", t3.TotalMilliseconds)); result.Print(); Assert.IsTrue(result.Calculate()); }
static void Main(string[] args) { var threadPool = new FixedThreadPool(3); var producerLow = StartTasks(threadPool, Priority.LOW, 20); var producerHigh = StartTasks(threadPool, Priority.HIGH, 20); var producerNormal = StartTasks(threadPool, Priority.NORMAL, 20); Task.WaitAll(producerLow, producerNormal, producerHigh); var pool = threadPool.Stop(); Task.WaitAll(pool); Console.ReadKey(); }
static void Main(string[] args) { var commandArgs = ParseCommandArgs(args); if (commandArgs == null) { PrintHelp(); return; } Console.WriteLine($"Starting {commandArgs.NumTasks} tasks with {commandArgs.NumThreads} threads."); Console.WriteLine(); try { var threadPool = new FixedThreadPool(commandArgs.NumThreads); var rnd = new Random(1); var stdWriters = Enumerable.Range(1, commandArgs.NumTasks) .Select(i => new StdOutWriter(GeneratePriority(rnd), commandArgs.Delay)); var sw = new Stopwatch(); sw.Start(); foreach (var stdWriter in stdWriters) { threadPool.Execute(stdWriter, stdWriter.Priority); } threadPool.Stop(); sw.Stop(); Console.WriteLine(); Console.WriteLine(sw.Elapsed); } catch (Exception ex) { Console.WriteLine(ex); Console.WriteLine(); PrintHelp(); } }
private static async Task StartTasks(FixedThreadPool threadPool, Priority priority, int count) { await Task.Run(() => { foreach (var ind in Enumerable.Range(0, count)) { threadPool.Execute(new ActionTask( () => { var delay = _random.Next(1000) / 1000.0; Thread.Sleep(TimeSpan.FromSeconds(delay)); Console.WriteLine($"Task with priority {priority} number {ind} fromy thread Id = {Thread.CurrentThread.ManagedThreadId}, complexity = {delay}"); }), priority); } } ); }
public static async Task Main() { var threadPool = new FixedThreadPool(workCount: 9); await ExecuteTasks(threadPool, 100); await Task.Delay(TimeSpan.FromSeconds(3)); Console.WriteLine("Add some more tasks."); await ExecuteTasks(threadPool, 50); await Task.Delay(TimeSpan.FromSeconds(3)); Console.WriteLine("Stop the thread pool."); await threadPool.Stop(); Console.WriteLine("Simulate executing tasks after the thread pool is stopped."); await ExecuteTasks(threadPool, 10); }
public void TestStop() { var pool = new FixedThreadPool(5); TestTask task = new TestTask("1", State.Priority.Normal, 1000); bool addResult = pool.Execute(task, task.Priority); Assert.AreEqual(true, addResult); Thread.Sleep(2000); Assert.AreEqual(true, task.IsStarted); Assert.AreEqual(true, task.IsStopped); pool.Stop(); addResult = pool.Execute(task, State.Priority.Normal); Assert.AreEqual(false, addResult); }
public void ExecuteTasks_Faster_InManyThreadsThanInOneThread(int times = 2, int threads = 8) { Action task = () => Thread.Sleep(1000); var stopwatch = new Stopwatch(); var successes = 0; for (var i = 0; i < times; i++) { var oneThreadPool = new FixedThreadPool(1); stopwatch.Restart(); for (var j = 0; j < threads; j++) { oneThreadPool.Execute(task); } oneThreadPool.Stop(); stopwatch.Stop(); var oneThreadTime = stopwatch.Elapsed; var multiThreadPool = new FixedThreadPool(threads); stopwatch.Restart(); for (var j = 0; j < threads; j++) { multiThreadPool.Execute(task); } multiThreadPool.Stop(); stopwatch.Stop(); var multiThreadTime = stopwatch.Elapsed; if (multiThreadTime < oneThreadTime) { successes++; } } Assert.That(successes, Is.EqualTo(times)); }
public FixedThreadPoolTests() { _threadPool = new FixedThreadPool(5); }
public LogManager(string log) { tp = new FixedThreadPool(1); logfile = log; }
/// <summary> /// Update the library when invoked via the timer /// </summary> private void UpdateLibrary() { try { // get a hook to the DB IDBClient db = Database.RetrieveClient(); // retrieve the initial number of tracks int beforeTracks = Database.RetrieveNumberOfTracks(db); // get the audio library locations IList <AudioLibraryLocation> locations = Database.RetrieveLibraryLocations(db); // get the current timestamp, we'll use this in case anything gets modified while this is happening DateTime beforeUpdate = DateTime.Now; _log.Info("Starting library update at: " + beforeUpdate.ToLocalTime()); try { // recurse through each of the library locations foreach (AudioLibraryLocation location in locations) { if (_log.IsDebugEnabled) { _log.Debug("Updating library location: " + location.Path); } // initialise the list of directories to process IList <string> directoriesToProcess = new List <string>(); // start traversing down each directory ProcessDirectory(directoriesToProcess, location.Path, location.LastWritten); // if there was any processing needed to be done if (directoriesToProcess.Count > 0) { const int numThreads = 5; _libraryThreadPool = new FixedThreadPool(5, ThreadPriority.Lowest); _log.Debug("Created custom thread pool for library with " + numThreads + " threads"); // make all the workers for (int i = 0; i < directoriesToProcess.Count; i++) { var worker = new AudioLibraryWorker(); worker.Directory = directoriesToProcess[i]; // attach it to a worker for the pool var workerItem = new WorkerItem(worker.WorkerMethod); // add it to the pool _libraryThreadPool.QueueWorkerItem(workerItem); // start the show _libraryThreadPool.Start(); } } // reset the reference to when this update run started location.LastWritten = beforeUpdate; // store this updated location back in the DB Database.UpdateAddLibraryLocation(db, location); // commit after each location. if something goes wrong, we wont have to redo db.Commit(); } // get the number of tracks after int afterTracks = Database.RetrieveNumberOfTracks(db); TimeSpan elapsedTime = DateTime.Now - beforeUpdate; _log.Info("Finished library update at: " + DateTime.Now.ToLocalTime() + ". Took: " + elapsedTime.TotalSeconds + " seconds"); _log.Info("Imported " + (afterTracks - beforeTracks) + " tracks"); // close the db db.Close(); } catch (DatabaseClosedException) { _log.Debug("The database has been closed prematurely"); } } catch (Db4oException ex) { _log.Error("Problem occurred when updating library", ex); } finally { _libraryUpdateTimer.Start(); } }
/// <summary> /// Метод тестрирования под различным количеством потоквов. /// </summary> /// <param name="poolCount"></param> public void ExecuteTest_AnyPoolWithPriority(int poolCount) { TestConditions result = new TestConditions(); // перенос из стека в память. int poolCountCopy = (int)(object)poolCount; FixedThreadPool pool = new FixedThreadPool(poolCountCopy); Collection <TaskInfo> infoInit = new Collection <TaskInfo>(); Collection <TaskInfo> infoAfter = new Collection <TaskInfo>(); Random rnd = new Random(); int pr; const int attemps = 100; for (int i = 0; i < attemps; i++) { TaskPriorityEx priority; pr = rnd.Next(0, 3); switch (pr) { case 0: priority = TaskPriorityEx.LOW; break; case 1: priority = TaskPriorityEx.NORMAL; break; case 2: priority = TaskPriorityEx.HIGH; break; default: priority = TaskPriorityEx.LOW; break; } int copyI = i; infoInit.Add(new TaskInfo(copyI, priority, DateTime.Now)); if (!pool.Execute( () => { infoAfter.Add(new TaskInfo(copyI, priority, DateTime.Now)); Console.WriteLine(string.Format("Task {0} {1}", copyI, priority)); Thread.Sleep(30); }, priority)) { result.Add(() => false, () => "Void Execute return FALSE unexpectedly"); } } Thread.Sleep((int)(attemps * 30 / (double)poolCountCopy) + 1000); int noNormalCount = 0; int normalStep = 0; TriggerT <int> trgNormal = new TriggerT <int>(); for (int i = 0; i < attemps; i++) { int copyI = i; if (i < poolCountCopy) { IEnumerable <TaskInfo> infors = infoInit.Where(item => item.Id == infoAfter[i].Id); if (infors.Count() > 0) { infoInit.Remove(infors.First()); } else { result.Add(() => false, () => string.Format("{0} is bad", copyI)); } } else { IEnumerable <TaskInfo> infors = infoInit.Where(item => item.Id == infoAfter[i].Id); if (infors.Count() > 0) { if (infors.First().Priority == TaskPriorityEx.NORMAL) { normalStep = i; } else { if (normalStep == 0) { noNormalCount++; } } if (noNormalCount > 5) { result.Add(() => false, () => string.Format("{0} - NORMAL doesn't exist to long", copyI)); } int normalStCp = normalStep; if (normalStCp < 30) { if (trgNormal.Calculate(normalStep)) { result.Add(() => { if (infoAfter[normalStCp + 1].Priority == TaskPriorityEx.HIGH && infoAfter[normalStCp + 2].Priority == TaskPriorityEx.HIGH && infoAfter[normalStCp + 3].Priority == TaskPriorityEx.HIGH && infoAfter[normalStCp + 4].Priority == TaskPriorityEx.NORMAL) { return(true); } else { return(false); } }, () => string.Format("{0} - Not accurate orders of HIGH and NORMAL", copyI)); } } infoInit.Remove(infors.First()); } else { result.Add(() => false, () => string.Format("{0} - is bad", copyI)); } } } result.Print(); Assert.IsTrue(result.Calculate()); }