public SignalAndWait ( TimeSpan timeout ) : Boolean | ||
timeout | TimeSpan | A |
return | Boolean |
/// <summary> /// Download all the images for the current session /// </summary> public void DownloadAllTreatmentImages() { Barrier barrier = new Barrier(_patient.PatientTreatment.TrainingList.Count + 2); Task treatmentThread = new Task(() => { //Downloading all thumbs in treatment DownloadTreatment(); barrier.SignalAndWait(); }); treatmentThread.Start(); foreach(Training t in _patient.PatientTreatment.TrainingList) { Task tt = new Task(() => { DownloadTraining(_patient.PatientTreatment.TrainingList.IndexOf(t)); barrier.SignalAndWait(); }); tt.Start(); } barrier.SignalAndWait(); barrier.Dispose(); }
public static void DegreeOfParallelism_Barrier(Labeled<ParallelQuery<int>> labeled, int count, int degree) { using (ThreadPoolHelpers.EnsureMinThreadsAtLeast(degree)) { var barrier = new Barrier(degree); Assert.Equal(Functions.SumRange(0, count), labeled.Item.WithDegreeOfParallelism(degree).Sum(x => { barrier.SignalAndWait(); return x; })); } }
public void TestEtw() { using (var listener = new TestEventListener("System.Threading.Tasks.Parallel.EventSource", EventLevel.Verbose)) { var events = new ConcurrentQueue<int>(); listener.RunWithCallback(ev => events.Enqueue(ev.EventId), () => { Parallel.For(0, 10000, i => { }); var barrier = new Barrier(2); Parallel.Invoke( () => barrier.SignalAndWait(), () => barrier.SignalAndWait()); }); const int BeginLoopEventId = 1; const int BeginInvokeEventId = 3; Assert.Equal(expected: 1, actual: events.Count(i => i == BeginLoopEventId)); Assert.Equal(expected: 1, actual: events.Count(i => i == BeginInvokeEventId)); const int EndLoopEventId = 2; const int EndInvokeEventId = 4; Assert.Equal(expected: 1, actual: events.Count(i => i == EndLoopEventId)); Assert.Equal(expected: 1, actual: events.Count(i => i == EndInvokeEventId)); const int ForkEventId = 5; const int JoinEventId = 6; Assert.True(events.Count(i => i == ForkEventId) >= 1); Assert.Equal(events.Count(i => i == ForkEventId), events.Count(i => i == JoinEventId)); } }
static void Main(string[] args) { // create a barrier Barrier barrier = new Barrier(2); // create a task that will complete Task.Factory.StartNew(() => { Console.WriteLine("Good task starting phase 0"); barrier.SignalAndWait(); Console.WriteLine("Good task starting phase 1"); barrier.SignalAndWait(); Console.WriteLine("Good task completed"); }); // create a task that will throw an exception // with a selective continuation that will reduce the // particpant count in the barrier Task.Factory.StartNew(() => { Console.WriteLine("Bad task 1 throwing exception"); throw new Exception(); }).ContinueWith(antecedent => { // reduce the particpant count Console.WriteLine("Reducing the barrier participant count"); barrier.RemoveParticipant(); }, TaskContinuationOptions.OnlyOnFaulted); // wait for input before exiting Console.WriteLine("Press enter to finish"); Console.ReadLine(); }
public void Construct_GivenSemaphoreSlim_ShouldLockIt() { //---------------Set up test pack------------------- using (var semaphore = new SemaphoreSlim(1)) { bool? gotLock = null; //---------------Assert Precondition---------------- using (new LenientAutoLocker(semaphore)) { var barrier = new Barrier(2); Task.Run(() => { barrier.SignalAndWait(); Thread.Sleep(1000); // ReSharper disable once AccessToDisposedClosure gotLock = semaphore.Wait(100); }); //---------------Execute Test ---------------------- barrier.SignalAndWait(); Thread.Sleep(2000); //---------------Test Result ----------------------- Assert.IsNotNull(gotLock); Assert.IsFalse(gotLock.Value); } } }
public void SimpleLock_WhenDeadlocked_Throws() { object lock1 = new object(); object lock2 = new object(); Barrier barrier = new Barrier(2); Action t1 = () => { lock (lock1) { barrier.SignalAndWait(); lock (lock2) { Thread.Sleep(100); } } }; Action t2 = () => { lock (lock2) { barrier.SignalAndWait(); lock (lock1) { Thread.Sleep(100); } } }; TestHelpers.InvokeSimultaneouslyAndWaitForDeadlockDetection(t1, t2); }
public async Task ExecuteTasksSequentiallyAndInOrder() { using (var testSubject = new MissionControl()) { var fool = testSubject.SpawnFool(); var sentMessage = new SimpleTestMessage(); SimpleTestMessage receivedMessage = null; var barrier = new Barrier(2); var first = fool.DoWork( sentMessage, msg => { barrier.SignalAndWait(); receivedMessage = msg; }); var second = fool.DoWork(sentMessage, msg => { barrier.SignalAndWait(); }); var done = Task.WhenAll(first, second) .ContinueWith( t => { barrier.Dispose(); return Work.Completed; }); var timeout = Task.Delay(100.Milliseconds()) .ContinueWith(t => Work.TimedOut); var result = await await Task.WhenAny(done, timeout); result.Should() .Be(Work.TimedOut); } }
public void Test_ClearDeadThreads() { //---------------Set up test pack------------------- const int BarrierTimeout = 10000; var dataAccessorMain = new DataAccessorInMemory(); var dataAccessor = new DataAccessorThreadSplitter(dataAccessorMain); var expectedDataAccessorForThread = new DataAccessorInMemory(); using (var entryBarrier = new Barrier(2)) using (var exitBarrier = new Barrier(2)) { var thread = new Thread(() => { dataAccessor.AddDataAccessorForThread(expectedDataAccessorForThread); entryBarrier.SignalAndWait(BarrierTimeout); exitBarrier.SignalAndWait(BarrierTimeout); }); thread.Start(); entryBarrier.SignalAndWait(BarrierTimeout); //---------------Assert preconditions--------------- Assert.AreSame(expectedDataAccessorForThread, dataAccessor.GetDataAccessorForThread(thread)); //---------------Execute Test ---------------------- exitBarrier.SignalAndWait(BarrierTimeout); thread.Join(); dataAccessor.ClearDeadThreads(); //---------------Test Result ----------------------- var exception = Assert.Throws<HabaneroDeveloperException>(() => dataAccessor.GetDataAccessorForThread(thread)); StringAssert.Contains("Data accessor for thread does not exist", exception.Message); } }
public void Test_WithThread() { //---------------Set up test pack------------------- const int BarrierTimeout = 10000; var dataAccessorMain = new DataAccessorInMemory(); var dataAccessor = new DataAccessorThreadSplitter(dataAccessorMain); var expectedDataAccessorForThread = new DataAccessorInMemory(); using (var entryBarrier = new Barrier(2)) using (var exitBarrier = new Barrier(2)) { var thread = new Thread(() => { dataAccessor.AddDataAccessorForThread(expectedDataAccessorForThread); entryBarrier.SignalAndWait(BarrierTimeout); exitBarrier.SignalAndWait(BarrierTimeout); }); thread.Start(); entryBarrier.SignalAndWait(BarrierTimeout); //---------------Execute Test ---------------------- var dataAccessorForThread = dataAccessor.GetDataAccessorForThread(thread); exitBarrier.SignalAndWait(BarrierTimeout); //---------------Test Result ----------------------- Assert.AreSame(expectedDataAccessorForThread, dataAccessorForThread); } }
public void CreateFor_GivenActionAndNoInterval_ShouldRunActionOnceInASecond() { //---------------Set up test pack------------------- var sut = Create(); var barrier1 = new Barrier(2); var barrier2 = new Barrier(2); var runs = 0; //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- sut.CreateFor(() => { if (runs == 0) barrier1.SignalAndWait(); if (++runs == 2) barrier2.SignalAndWait(); }); barrier1.SignalAndWait(); Thread.Sleep(1000); var start = DateTime.Now; barrier2.SignalAndWait(); var end = DateTime.Now; //---------------Test Result ----------------------- Assert.That(end - start, Is.LessThanOrEqualTo(TimeSpan.FromMilliseconds(500))); }
private static int[] CalculatePrimesParallel(int range) { var results = new List<int>(); var b = new Barrier(Environment.ProcessorCount + 1); for(var core=0; core < Environment.ProcessorCount; ++core) { var coreX = core; ThreadPool.QueueUserWorkItem((o) => { var threadResults = new List<int>(); for (var number = 3 + coreX; number < range; number += Environment.ProcessorCount) { var foundPrime = true; for (var divisor = 2; divisor * divisor <= number; divisor++) if (number % divisor == 0) foundPrime = false; if (foundPrime) { results.Add(number); } } b.SignalAndWait(); }); } b.SignalAndWait(); return results.ToArray(); }
public static void Water() { Console.WriteLine("Putting water to boil (takes a bit longer)"); Thread.Sleep(2000); barrier.SignalAndWait(); Console.WriteLine("Pouring water into cup."); barrier.SignalAndWait(); Console.WriteLine("Turn off the water heater."); }
public static void Water() { Console.WriteLine("Phase 0. Putting the kettle on (takes a bit longer)"); Thread.Sleep(2000); barrier.SignalAndWait(); Console.WriteLine("Phase 1. Pouring water into cup"); barrier.SignalAndWait(); Console.WriteLine("Phase 2. Putting the kettle away"); }
public void TestBackgroundWorkerBasic() { var orignal = SynchronizationContext.Current; try { SynchronizationContext.SetSynchronizationContext(null); const int expectedResult = 42; const int expectedReportCallsCount = 5; int actualReportCallsCount = 0; var worker = new BackgroundWorker() { WorkerReportsProgress = true }; var progressBarrier = new Barrier(2, barrier => ++actualReportCallsCount); var workerCompletedEvent = new ManualResetEventSlim(false); worker.DoWork += (sender, e) => { for (int i = 0; i < expectedReportCallsCount; i++) { worker.ReportProgress(i); progressBarrier.SignalAndWait(); } e.Result = expectedResult; }; worker.RunWorkerCompleted += (sender, e) => { try { Assert.Equal(expectedResult, (int)e.Result); Assert.False(worker.IsBusy); } finally { workerCompletedEvent.Set(); } }; worker.ProgressChanged += (sender, e) => { progressBarrier.SignalAndWait(); }; worker.RunWorkerAsync(); // wait for singal from WhenRunWorkerCompleted Assert.True(workerCompletedEvent.Wait(TimeoutLong)); Assert.False(worker.IsBusy); Assert.Equal(expectedReportCallsCount, actualReportCallsCount); } finally { SynchronizationContext.SetSynchronizationContext(orignal); } }
public void CurrentManagedThreadId_DifferentForActiveThreads() { var ids = new HashSet<int>(); Barrier b = new Barrier(10); Task.WaitAll((from i in Enumerable.Range(0, b.ParticipantCount) select Task.Factory.StartNew(() => { b.SignalAndWait(); lock (ids) ids.Add(Environment.CurrentManagedThreadId); b.SignalAndWait(); }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default)).ToArray()); Assert.Equal(b.ParticipantCount, ids.Count); }
static void Main(string[] args) { var participants = 5; // We create a CancellationTokenSource to be able to initiate the cancellation var tokenSource = new CancellationTokenSource(); // We create a barrier object to use it for the rendez-vous points var barrier = new Barrier(participants, b => { Console.WriteLine("{0} paricipants are at rendez-vous point {1}.", b.ParticipantCount, b.CurrentPhaseNumber); }); for (int i = 0; i < participants; i++) { var localCopy = i; Task.Delay(1000 * localCopy + 1, tokenSource.Token) .ContinueWith(_ => { Console.WriteLine("Task {0} left point A!", localCopy); Thread.Sleep(1000 * localCopy + 1); // Do some "work" if (localCopy % 2 == 0) { Console.WriteLine("Task {0} arrived at point B!", localCopy); barrier.SignalAndWait(tokenSource.Token); } else { Console.WriteLine("Task {0} changed its mind and went back!", localCopy); barrier.RemoveParticipant(); return; } }, TaskContinuationOptions.NotOnCanceled) .ContinueWith(_ => { Thread.Sleep(1000 * localCopy + 1); Console.WriteLine("Task {0} arrived at point C!", localCopy); barrier.SignalAndWait(tokenSource.Token); }, TaskContinuationOptions.NotOnCanceled); } Console.WriteLine("Main thread is waiting for {0} tasks!", barrier.ParticipantsRemaining - 1); Console.WriteLine("Press enter to cancel!"); Console.ReadLine(); if (barrier.CurrentPhaseNumber < 2) { tokenSource.Cancel(); Console.WriteLine("We canceled the operation!"); } else { Console.WriteLine("Too late to cancel!"); } Console.WriteLine("Main thread is done!"); Console.ReadLine(); }
public void TransactionTest_forceDistributedTransaction() { var id = new Guid("9e15c907-68da-44a0-8197-81c0ef1d88c9"); var barrier = new Barrier(2); using (GetNewServer(requestedStorage: "esent")) using (var documentStore = new DocumentStore() { Url = "http://localhost:8079", EnlistInDistributedTransactions = true }.Initialize()) { if(documentStore.DatabaseCommands.GetStatistics().SupportsDtc == false) return; using (var session = documentStore.OpenSession()) { session.Store(new LocationView{Id = id}); session.SaveChanges(); } // Delete location (savechanges immediately) but rollback efter sleeping 10 seconds var task = new Task(() => { using (var tx = new TransactionScope()) { ForceDistributedTransaction(); using (var session = documentStore.OpenSession()) { session.Advanced.AllowNonAuthoritativeInformation = false; var locationView = session.Load<LocationView>(id); session.Delete(locationView); session.SaveChanges(); } barrier.SignalAndWait(); barrier.SignalAndWait(); // We don't complete so the deletion will rollback } }); task.Start(); barrier.SignalAndWait(); Assert.True(CanReadLocation(documentStore, id, forceDistributedTransaction: true)); barrier.SignalAndWait(); task.Wait(); Assert.True(CanReadLocation(documentStore, id, forceDistributedTransaction: true)); } }
static void Main(string[] args) { const int numberTasks = 2; const int partitionSize = 1000000; var data = new List <string>(FillData(partitionSize * numberTasks)); var barrier = new System.Threading.Barrier(numberTasks + 1); var taskFactory = new TaskFactory(); var tasks = new Task <int[]> [numberTasks]; for (int i = 0; i < numberTasks; i++) { tasks[i] = taskFactory.StartNew <int[]>(CalculationInTask, Tuple.Create(i, partitionSize, barrier, data)); } barrier.SignalAndWait(); var resultCollection = tasks[0].Result.Zip(tasks[1].Result, (c1, c2) => { return(c1 + c2); }); char ch = 'a'; int sum = 0; }
public void Barrier() { var range = Enumerable.Range(0, 10).ToList(); var barrier = new Barrier(range.Count + 1); Parallel.ForEach(range, i => { Task.Run(() => { Console.Write(i + " "); barrier.SignalAndWait(); Console.WriteLine($"{i} stopped"); }); }); barrier.SignalAndWait(); Console.WriteLine("done"); }
public void ObjectFromEmptyContainerConcurently() { const int Threads = 40; var barrier = new System.Threading.Barrier(Threads); var countdown = new CountdownEvent(Threads); var random = new Random(); var errors = false; for (int i = 0; i < Threads; i++) { Task.Factory.StartNew( wait => { barrier.SignalAndWait(); Task.Delay((int)wait).Wait(); try { var result = Container.Resolve <object>(); } catch { errors = true; } countdown.Signal(); }, random.Next(0, 3), TaskCreationOptions.LongRunning); } countdown.Wait(); Assert.IsFalse(errors); }
public static bool CancelAfterWait() { TestHarness.TestLog("* BarrierCancellationTests.CancelAfterWait()"); bool passed = true; CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(); CancellationToken cancellationToken = cancellationTokenSource.Token; const int numberParticipants = 3; Barrier barrier = new Barrier(numberParticipants); ThreadPool.QueueUserWorkItem( (args) => { Thread.Sleep(1000); cancellationTokenSource.Cancel(); } ); //Now wait.. the wait should abort and an exception should be thrown passed &= TestHarnessAssert.EnsureOperationCanceledExceptionThrown( () => barrier.SignalAndWait(cancellationToken), cancellationToken, "An OCE(null) should have been thrown that references the cancellationToken."); //Test that backout occured. passed &= TestHarnessAssert.AreEqual(numberParticipants, barrier.ParticipantsRemaining, "All participants should remain as the current one should have backout out its signal"); // the token should not have any listeners. // currently we don't expose this.. but it was verified manually return passed; }
private void RoutePeerMessages(CancellationToken token, Barrier gateway) { try { using (var scaleOutFrontend = CreateScaleOutFrontendSocket()) { var localSocketIdentity = localSocketIdentityPromise.Task.Result; gateway.SignalAndWait(token); while (!token.IsCancellationRequested) { try { var message = (Message) scaleOutFrontend.ReceiveMessage(token); if (message != null) { message.SetSocketIdentity(localSocketIdentity); scaleOutFrontend.SendMessage(message); messageTracer.ReceivedFromOtherNode(message); } } catch (Exception err) { logger.Error(err); } } } } catch (Exception err) { logger.Error(err); } }
public void TestAbilityToFireImmediatelyWhenStartedBefore() { List<DateTime> jobExecTimestamps = new List<DateTime>(); Barrier barrier = new Barrier(2); IScheduler sched = CreateScheduler("testAbilityToFireImmediatelyWhenStartedBefore", 5); sched.Context.Put(Barrier, barrier); sched.Context.Put(DateStamps, jobExecTimestamps); sched.Start(); Thread.Yield(); IJobDetail job1 = JobBuilder.Create<TestJobWithSync>() .WithIdentity("job1") .Build(); ITrigger trigger1 = TriggerBuilder.Create() .ForJob(job1) .Build(); DateTime sTime = DateTime.UtcNow; sched.ScheduleJob(job1, trigger1); barrier.SignalAndWait(testTimeout); sched.Shutdown(false); DateTime fTime = jobExecTimestamps[0]; Assert.That(fTime - sTime < TimeSpan.FromMilliseconds(7000), "Immediate trigger did not fire within a reasonable amount of time."); }
public void Instance_ThreadSafe() { using (var gate = new Barrier(5)) { var result = new ConcurrentBag<AnyConstructorFinder>(); Action test = () => { gate.SignalAndWait(20); var instance = AnyConstructorFinder.Instance; Thread.MemoryBarrier(); result.Add(instance); }; var cycleState = Parallel.For(0, 200, new ParallelOptions { MaxDegreeOfParallelism = 15 }, x => { test(); }) ; while (!cycleState.IsCompleted) { Thread.Sleep(100); } Assert.IsTrue(result.All(x => x != null)); Assert.IsTrue(result.Distinct().Count() == 1); } }
static void Main() { const int numberTasks = 2; const int partitionSize = 1000000; var data = new List<string>(FillData(partitionSize * numberTasks)); var barrier = new Barrier(numberTasks + 1); var taskFactory = new TaskFactory(); var tasks = new Task<int[]>[numberTasks]; for (int i = 0; i < numberTasks; i++) { tasks[i] = taskFactory.StartNew<int[]>(CalculationInTask, Tuple.Create(i, partitionSize, barrier, data)); } barrier.SignalAndWait(); var resultCollection = tasks[0].Result.Zip(tasks[1].Result, (c1, c2) => { return c1 + c2; }); char ch = 'a'; int sum = 0; foreach (var x in resultCollection) { Console.WriteLine("{0}, count: {1}", ch++, x); sum += x; } Console.WriteLine("main finished {0}", sum); Console.WriteLine("remaining {0}, phase {1}", barrier.ParticipantsRemaining, barrier.CurrentPhaseNumber); }
public void TestPoolContention() { var barrier = new Barrier(N); var tasks = new Task[N]; var totalTimesAcquired = 0; Assert.AreEqual(pool.maxThingId, 0); for (int i = 0; i < N; i++) { var t = Task.Run(() => { barrier.SignalAndWait(); // Takes time for all threads to spin up for (int j = 0; j < 128; j++) { using (var pooled = pool.GetAsync().Result) // blocks { Interlocked.Increment(ref totalTimesAcquired); } } }); tasks[i] = t; // These N tasks do not yield their thread } Task.WaitAll(tasks); Assert.AreEqual(PoolSize, pool.maxThingId); Assert.AreEqual(PoolSize, pool.CurrentFreeCount); Assert.AreEqual(PoolSize, pool.CurrentPoolSize); Assert.AreEqual(N * 128, totalTimesAcquired); }
public void EventRaisedWithActionHandler() { RunWithoutSyncCtx(() => { Barrier b = new Barrier(2); Progress<int> p = new Progress<int>(i => { Assert.Equal(b.CurrentPhaseNumber, i); b.SignalAndWait(); }); for (int i = 0; i < 3; i++) { ((IProgress<int>)p).Report(i); b.SignalAndWait(); } }); }
public void Append_GivenLoggingEvent_WhenIsFirstEvent_ShouldKickOffTaskToLogToSplunk() { //---------------Set up test pack------------------- var factory = Substitute.For<ISplunkWriterFactory>(); var taskRunner = Substitute.For<ITaskRunner>(); var db = Substitute.For<ILogBufferItemRepository>(); var dbFactory = CreateSubstituteBufferFactoryWith(db); Task<AsyncLogResult> logTask = null; var firstBarrier = new Barrier(2); var secondBarrier = new Barrier(2); taskRunner.Run(Arg.Any<Func<AsyncLogResult>>()) .ReturnsForAnyArgs(ci => { logTask = new Task<AsyncLogResult>(() => { var result = ci.Arg<Func<AsyncLogResult>>()(); firstBarrier.SignalAndWait(); secondBarrier.SignalAndWait(); // don't let this exit here to prove unbuffer didn't happen return result; }); return logTask; }); var sut = Create(taskRunner, factory, dbFactory); sut.Name = RandomValueGen.GetRandomString(1, 10); var logEvent = CreateRandomLoggingEvent(); var writer = Substitute.For<ISplunkWriter>(); factory.CreateFor(sut.Name).ReturnsForAnyArgs(ci => writer); writer.Log(Arg.Any<string>()) .ReturnsForAnyArgs(ci => ImmediateTaskRunnerBuilder.CreateImmediateTaskFor(() => true)); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- sut.DoAppend(logEvent); //---------------Test Result ----------------------- // not called just yet... factory.Received().CreateFor(sut.Name); writer.DidNotReceive().Log(Arg.Any<string>()); logTask.Start(); firstBarrier.SignalAndWait(); writer.Received().Log(JsonConvert.SerializeObject(logEvent, Formatting.None, new JsonConverterWhichProducesHierachicalOutputOnLog4NetMessageObjects())); db.DidNotReceive().Unbuffer(Arg.Any<long>()); }
public void MultpleTimers_PeriodicTimerIsntBlockedByBlockedCallback() { int callbacks = 2; Barrier b = new Barrier(callbacks + 1); Timer t = null; t = new Timer(_ => { if (Interlocked.Decrement(ref callbacks) >= 0) { Assert.True(b.SignalAndWait(MaxPositiveTimeoutInMs)); } t.Dispose(); }, null, -1, -1); t.Change(1, 50); Assert.True(b.SignalAndWait(MaxPositiveTimeoutInMs)); GC.KeepAlive(t); }
public void Start() { _barrier = new Barrier(2); _worker = new Thread(Worker); _worker.Start(); _barrier.SignalAndWait(); _barrier.Dispose(); _barrier = null; }
public void EventRaisedWithEventHandler() { RunWithoutSyncCtx(() => { Barrier b = new Barrier(2); Progress<int> p = new Progress<int>(); p.ProgressChanged += (s, i) => { Assert.Same(s, p); Assert.Equal(b.CurrentPhaseNumber, i); b.SignalAndWait(); }; for (int i = 0; i < 3; i++) { ((IProgress<int>)p).Report(i); b.SignalAndWait(); } }); }
public StopTheThreadPoolContext() { int numProcs = Environment.ProcessorCount; var barrier = new Barrier(numProcs + 1); ThreadPool.GetMaxThreads(out originalWorkerThreads, out originalIOThreads); ThreadPool.SetMaxThreads(numProcs, originalIOThreads); for (int i = 0; i < numProcs; i++) { ThreadPool.QueueUserWorkItem( delegate { barrier.SignalAndWait(); testComplete.Wait(); }); } barrier.SignalAndWait(); }
public void Test() { var container = Container(); var barrier = new Barrier(2); var otherThreadTask = Task.Run(delegate { barrier.SignalAndWait(); container.Get<A>(); }); var error = Assert.Throws<SimpleContainerException>(() => { barrier.SignalAndWait(); Thread.Sleep(20); container.Get<A>(); }); var isValidException = Is.EqualTo("parameter [parameter] of service [A] is not configured\r\n\r\n!A\r\n\tServiceWithDelay\r\n\t!parameter <---------------"); Assert.That(error.Message, isValidException); var otherTaskException = Assert.Throws<AggregateException>(otherThreadTask.Wait); Assert.That(otherTaskException.InnerExceptions.Single().Message, isValidException); }
static void Main() { const int numberTasks = 2; const int partitionSize = 1000000; const int loops = 5; var taskResults = new Dictionary<int, int[][]>(); var data = new List<string>[loops]; for (int i = 0; i < loops; i++) { data[i] = new List<string>(FillData(partitionSize * numberTasks)); } var barrier = new Barrier(1); LogBarrierInformation("initial participants in barrier", barrier); for (int i = 0; i < numberTasks; i++) { barrier.AddParticipant(); int jobNumber = i; taskResults.Add(i, new int[loops][]); for (int loop = 0; loop < loops; loop++) { taskResults[i][loop] = new int[26]; } WriteLine($"Main - starting task job {jobNumber}"); Task.Run(() => CalculationInTask(jobNumber, partitionSize, barrier, data, loops, taskResults[jobNumber])); } for (int loop = 0; loop < 5; loop++) { LogBarrierInformation("main task, start signaling and wait", barrier); barrier.SignalAndWait(); LogBarrierInformation("main task waiting completed", barrier); // var resultCollection = tasks[0].Result.Zip(tasks[1].Result, (c1, c2) => c1 + c2); int[][] resultCollection1 = taskResults[0]; int[][] resultCollection2 = taskResults[1]; var resultCollection = resultCollection1[loop].Zip(resultCollection2[loop], (c1, c2) => c1 + c2); char ch = 'a'; int sum = 0; foreach (var x in resultCollection) { WriteLine($"{ch++}, count: {x}"); sum += x; } LogBarrierInformation($"main task finished loop {loop}, sum: {sum}", barrier); } WriteLine("at the end"); ReadLine(); }
private static void Participant1() { Console.WriteLine("Participant1 executing phase 0"); Barrier.SignalAndWait(); Console.WriteLine("Participant1 executing phase 1"); Barrier.SignalAndWait(); Console.WriteLine("Participant1 executing phase 2"); Barrier.SignalAndWait(); Console.WriteLine("Participant1 done with it's execution"); }
public void MultipleResolvesAtTheSameTimeCauseConcurrencyException() { var container = Container; container.RegisterInstance <string>("a value"); const int Threads = 40; var barrier = new System.Threading.Barrier(Threads); var countdown = new CountdownEvent(Threads); var random = new Random(); var errors = false; for (int i = 0; i < Threads; i++) { Task.Factory.StartNew( wait => { barrier.SignalAndWait(); Task.Delay((int)wait).Wait(); try { container.Resolve <ClassWithMultipleConstructorParameters>(); } catch { errors = true; } countdown.Signal(); }, random.Next(0, 3), TaskCreationOptions.LongRunning); } countdown.Wait(); Assert.IsFalse(errors); }