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));
}