public async Task Execute_Planed_Tasks() { var count = 0; _threadPool.Execute(new ActionTask(() => Interlocked.Increment(ref count)), Priority.NORMAL); await _threadPool.Stop(); Assert.Equal(1, count); }
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)); }
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 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()); }
private void btnDownload_Click(object sender, EventArgs e) { _downloading = !_downloading; if (_downloading) { Download(); btnDownload.Text = "Stop"; } else { _threadPool.Stop(); btnDownload.Text = "Download"; } }
public void ExecuteTest_TwoPoolWithStop() { 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"); } pool.Stop(); Thread.Sleep(2500); if (pool.Execute(() => { started3 = DateTime.Now; Console.WriteLine("Task 3"); Thread.Sleep(100); })) { result.Add(() => false, () => "Void Execute return TRUE 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.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(); } }
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)); }