public void RunApplicationTest()
{
var parameters = new[] { "a", "b", "longParam with spaces and ` \x305 other chars" };
var manager = SingleInstanceManager.CreateManager("unitTest");
var start1 = manager.RunApplication(new string[] { });
Assert.AreEqual(true, start1);
var m = new Barrier(2);
manager.SecondInstanceStarted += (sender, e) =>
{
CollectionAssert.AreEqual(parameters, e.CommandLineParameters);
m.SignalAndWait();
m.Dispose();
};
var t = new Thread(() =>
{
var start2 = manager.RunApplication(parameters);
Assert.AreEqual(false, start2);
});
t.Start();
t.Join();
if (!m.SignalAndWait(10000))
{
Assert.Warn("Signal timed out");
}
;
manager.Shutdown();
}
/// <summary cref="DisposeBase.Dispose(bool)"/>
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
lock (taskSynchronizationObject)
{
running = false;
currentTask = null;
Monitor.PulseAll(taskSynchronizationObject);
}
foreach (var thread in threads)
{
thread.Join();
}
threads = null;
foreach (var warp in warpContexts)
{
warp.Dispose();
}
warpContexts = null;
foreach (var group in groupContexts)
{
group.Dispose();
}
groupContexts = null;
finishedEvent.Dispose();
}
[Fact(Skip = "Barrier doesn't block the async sends in core.")] // TODO: make this test work
public async Task NotifyCallQueueOnEveryUserButPostingUser()
{
var service = GetService();
var topic = new Topic {
TopicID = 123
};
var user = new User {
UserID = 768
};
var list = new List <User> {
user, new User {
UserID = 2
}
};
_mockSubRepo.Setup(s => s.GetSubscribedUsersThatHaveViewed(topic.TopicID)).ReturnsAsync(list);
var topicLink = "foo";
Func <User, Topic, string> gen = (u, t) => "x" + u.UserID;
var barrier = new Barrier(1);
async Task ActionAsync()
{
await service.NotifySubscribers(topic, user, topicLink, gen);
barrier.SignalAndWait();
}
await ActionAsync();
barrier.Dispose();
_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, It.IsAny <User>(), topicLink, It.IsAny <string>()), Times.Exactly(1));
_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, list[0], topicLink, "x" + list[0].UserID), Times.Exactly(0));
_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, list[1], topicLink, "x" + list[1].UserID), Times.Exactly(1));
}
public void NotifyCallQueueOnEveryUserButPostingUser()
{
var service = GetService();
var topic = new Topic(123);
var user = new User(768, DateTime.MinValue);
var list = new List <User> {
user, new User(2, DateTime.MinValue)
};
_mockSubRepo.Setup(s => s.GetSubscribedUsersThatHaveViewed(topic.TopicID)).Returns(list);
var topicLink = "foo";
Func <User, string> gen = u => "x" + u.UserID;
var barrier = new Barrier(1);
Action action = () =>
{
service.NotifySubscribers(topic, user, topicLink, gen);
barrier.SignalAndWait();
};
action.Invoke();
barrier.Dispose();
_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, It.IsAny <User>(), topicLink, It.IsAny <string>()), Times.Exactly(1));
_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, list[0], topicLink, "x" + list[0].UserID), Times.Exactly(0));
_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, list[1], topicLink, "x" + list[1].UserID), Times.Exactly(1));
}
[Fact(Skip = "Barrier doesn't block the async sends in core.")] // TODO: make this test work
public void NotifyCallQueueOnEveryUser()
{
var service = GetService();
var topic = new Topic {
TopicID = 123
};
var list = new List <User> {
new User {
UserID = 1
}, new User {
UserID = 2
}
};
_mockSubRepo.Setup(s => s.GetSubscribedUsersThatHaveViewed(topic.TopicID)).Returns(list);
var topicLink = "foo";
Func <User, string> gen = u => "x" + u.UserID;
var barrier = new Barrier(1);
Action action = () => {
service.NotifySubscribers(topic, new User {
UserID = 45643
}, topicLink, gen);
barrier.SignalAndWait();
};
action();
barrier.Dispose();
_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, list[0], topicLink, "x" + list[0].UserID), Times.Once());
_mockSubTopicEmail.Verify(s => s.ComposeAndQueue(topic, list[1], topicLink, "x" + list[1].UserID), Times.Once());
}
/// <summary>
/// Dispose all managed resources allocated by this CPU accelerator instance.
/// </summary>
protected override void DisposeAccelerator_SyncRoot(bool disposing)
{
if (!disposing)
{
return;
}
// Dispose task engine
lock (taskSynchronizationObject)
{
running = false;
currentTask = null;
Monitor.PulseAll(taskSynchronizationObject);
}
// Dispose all multiprocessors
foreach (var multiprocessor in multiprocessors)
{
multiprocessor.Dispose();
}
// Dispose barriers
finishedEventPerMultiprocessor.Dispose();
taskConcurrencyLimit.Dispose();
}
public static void RunBarrierTest6_Dispose()
{
Barrier b = new Barrier(1);
b.Dispose();
Assert.Throws <ObjectDisposedException>(() => b.SignalAndWait());
}
/// <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 RunBarrierTest10c()
{
for (int j = 0; j < 10000; j++)
{
Task[] tasks = new Task[2];
Barrier b = new Barrier(3);
tasks[0] = Task.Run(() => b.SignalAndWait());
tasks[1] = Task.Run(() => b.SignalAndWait());
b.SignalAndWait();
b.Dispose();
GC.Collect();
try
{
Task.WaitAll(tasks);
}
catch
{
Assert.True(false, string.Format("RunBarrierTest10c: Error: Only finished {0} iterations, before an exception was thrown.", j));
}
}
}
/// <summary>
/// Depending on data destination calls appropriate functions to start measurement.
/// </summary>
/// <param name="tasks">A list of Tasks</param>
static void GoToRecorderRecordingState()
{
var threads = new Thread[numOfModules];
barrier = new Barrier(numOfModules);
try
{
for (int i = 0; i < numOfModules; i++)
{
threads[i] = new Thread((object idx) =>
{
if (destIsSDcard)
{
StartSDcarMeasuremnet((int)idx);
}
else
{
StartSocketMeasuremnet((int)idx);
}
});
threads[i].Start(i);
}
for (int i = 0; i < numOfModules; i++)
{
threads[i].Join();
}
}
catch (Exception ex)
{
Console.WriteLine("GoToRecorderRecordingState(exception): {0}", ex.Message);
}
barrier.Dispose();
}
// Demonstrates:
// Barrier constructor with post-phase action
// Barrier.AddParticipants()
// Barrier.RemoveParticipant()
// Barrier.SignalAndWait(), incl. a BarrierPostPhaseException being thrown
static void Main(string[] args)
{
int count = 0;
// Create a barrier with three participants
// Provide a post-phase action that will print out certain information
// And the third time through, it will throw an exception
Barrier barrier = new Barrier(3, (b) =>
{
Console.WriteLine("Post-Phase action: count={0}, phase={1}", count, b.CurrentPhaseNumber);
if (b.CurrentPhaseNumber == 2) /*throw new Exception("D'oh!");*/
{
Console.WriteLine("Currently the Phase number is 2");
}
});
// Nope -- changed my mind. Let's make it five participants.
barrier.AddParticipants(2);
// Nope -- let's settle on four participants.
barrier.RemoveParticipant();
// This is the logic run by all participants
Action action = () =>
{
Interlocked.Increment(ref count);
barrier.SignalAndWait(); // during the post-phase action, count should be 4 and phase should be 0
Interlocked.Increment(ref count);
barrier.SignalAndWait(); // during the post-phase action, count should be 8 and phase should be 1
// The third time, SignalAndWait() will throw an exception and all participants will see it
Interlocked.Increment(ref count);
try
{
barrier.SignalAndWait();
}
catch (Exception bppe)
{
Console.WriteLine("Caught BarrierPostPhaseException: {0}", bppe.Message);
}
// The fourth time should be hunky-dory
Interlocked.Increment(ref count);
barrier.SignalAndWait(); // during the post-phase action, count should be 16 and phase should be 3
};
// Now launch 4 parallel actions to serve as 4 participants
Parallel.Invoke(action, action, action, action);
// This (5 participants) would cause an exception:
// Parallel.Invoke(action, action, action, action, action);
// "System.InvalidOperationException: The number of threads using the barrier
// exceeded the total number of registered participants."
// It's good form to Dispose() a barrier when you're done with it.
barrier.Dispose();
Console.ReadKey();
}
public void Dispose()
{
if (barrier != null)
{
barrier.Dispose();
barrier = null;
}
}
public static void Run()
{
_tasks = new Task[_particapants];
_barrier = new Barrier(_particapants, (barrier) =>
{
Console.WriteLine("Current phase: {0}", barrier.CurrentPhaseNumber);
});
var sl = new SpinLock(false);
int totalRenders = 0;
for (int i = 0; i < _particapants; i++)
{
_tasks[i] = Task.Factory.StartNew((num) =>
{
var localsb = new StringBuilder();
var paiticipantNumber = (int)num;
for (int j = 0; j < 10; j++)
{
CreatePlanets(paiticipantNumber);
_barrier.SignalAndWait();
CreateStars(paiticipantNumber);
_barrier.SignalAndWait();
CheckCollisionBetweenPlanets(paiticipantNumber);
_barrier.SignalAndWait();
CheckCollisionBetweenStars(paiticipantNumber);
_barrier.SignalAndWait();
RenderCollisions(paiticipantNumber);
_barrier.SignalAndWait();
bool lockTaken = false;
try
{
sl.Enter(ref lockTaken);
// Spinlock acquired a lock
// Critical section
totalRenders++;
}
finally
{
if (lockTaken)
{
sl.Exit(false);
}
}
}
}, i);
}
//很多任务完成其工作之后
var finalTask = Task.Factory.ContinueWhenAll(_tasks, (tasks) =>
{
Task.WaitAll(_tasks);
Console.WriteLine("{0} renders were executed.", totalRenders);
_barrier.Dispose();
});
finalTask.Wait();
Console.ReadLine();
}
/// <summary cref="DisposeBase.Dispose(bool)"/>
protected override void Dispose(bool disposing)
{
if (disposing)
{
barrier.Dispose();
broadcastBuffer.Dispose();
}
base.Dispose(disposing);
}
/// <summary cref="DisposeBase.Dispose(bool)"/>
protected override void Dispose(bool disposing)
{
if (disposing)
{
groupBarrier.Dispose();
sharedMemoryBuffer.Dispose();
broadcastBuffer.Dispose();
}
base.Dispose(disposing);
}
private void EndWork()
{
Working = false;
if (_barrierForReps != null)
{
_barrierForReps.Dispose();
_barrierForReps = null;
}
_asyncOperation = null;
}
public void Dispose()
{
if (!_waited)
{
throw new ApplicationException("Please wait on barrier");
}
_barrier?.Dispose();
_barrier = null;
}
static void Main()
{
Console.WriteLine("人到齐了才能开会");
new Thread(Arrival1).Start();
new Thread(Arrival2).Start();
new Thread(Arrival3).Start();
Console.ReadKey();
b.Dispose();
}
public Task SwitchBuffer()
{
// Make sure that the agent is able to switch to the secondary buffer when the primary is full/busy
var api = new Mock <IApi>();
var agent = new AgentWriter(api.Object, statsd: null);
var barrier = new Barrier(2);
api.Setup(a => a.SendTracesAsync(It.IsAny <ArraySegment <byte> >(), It.IsAny <int>()))
.Callback(() =>
{
barrier.SignalAndWait();
barrier.SignalAndWait();
})
.Returns(Task.FromResult(true));
agent.WriteTrace(CreateTrace(1));
// Wait for the flush operation
barrier.SignalAndWait();
// At this point, the flush thread is stuck in Api.SendTracesAsync, and the frontBuffer should be active and locked
Assert.True(agent.ActiveBuffer == agent.FrontBuffer);
Assert.True(agent.FrontBuffer.IsLocked);
Assert.Equal(1, agent.FrontBuffer.TraceCount);
Assert.Equal(1, agent.FrontBuffer.SpanCount);
var mutex = new ManualResetEventSlim();
agent.WriteTrace(CreateTrace(2));
// Wait for the trace to be dequeued
WaitForDequeue(agent);
// Since the frontBuffer was locked, the buffers should have been swapped
Assert.True(agent.ActiveBuffer == agent.BackBuffer);
Assert.Equal(1, agent.BackBuffer.TraceCount);
Assert.Equal(2, agent.BackBuffer.SpanCount);
// Unblock the flush thread
barrier.SignalAndWait();
// Wait for the next flush operation
barrier.SignalAndWait();
// Back buffer should still be active and being flushed
Assert.True(agent.ActiveBuffer == agent.BackBuffer);
Assert.True(agent.BackBuffer.IsLocked);
Assert.False(agent.FrontBuffer.IsLocked);
// Unblock and exit
barrier.Dispose();
return(agent.FlushAndCloseAsync());
}
/// <inheritdoc/>
protected override void Dispose(bool disposing)
{
if (disposing)
{
barrier.Dispose();
foreach (var warpBarrier in warpBarriers)
{
warpBarrier.Dispose();
}
}
base.Dispose(disposing);
}
static void Main(string[] args)
{
_tasks = new Task[_participants];
_barrier = new Barrier(_participants, (barrier) =>
{
Console.WriteLine("Current phase: {0}",
barrier.CurrentPhaseNumber);
});
int totalRenders = 0;
for (int i = 0; i < _participants; i++)
{
_tasks[i] = Task.Factory.StartNew((num) =>
{
var participantNumber = (int)num;
for (int j = 0; j < 10; j++)
{
CreatePlanets(participantNumber);
_barrier.SignalAndWait();
CreateStars(participantNumber);
_barrier.SignalAndWait();
CheckCollisionsBetweenPlanets(participantNumber);
_barrier.SignalAndWait();
CheckCollisionsBetweenStars(participantNumber);
_barrier.SignalAndWait();
RenderCollisions(participantNumber);
_barrier.SignalAndWait();
// Increment totalRenders with an atomic operation
Interlocked.Increment(ref totalRenders);
}
}, i);
}
var finalTask = Task.Factory.ContinueWhenAll(_tasks, (tasks) =>
{
// Wait for all the tasks to ensure
// the propagation of any exception occurred
// in any of the _tasks
Task.WaitAll(_tasks);
Console.WriteLine(
"{0} renders were executed.",
totalRenders);
// Dispose the Barrier instance
_barrier.Dispose();
});
// Wait for finalTask to finish
finalTask.Wait();
Console.ReadLine();
}
public static async Task Run()
{
Barrier barrier = new Barrier(3, b =>
{
Console.WriteLine("Barrier method: phase={0}", b.CurrentPhaseNumber);
if (b.CurrentPhaseNumber == 2)
{
Console.WriteLine();
Console.WriteLine($"### Finished.");
Console.WriteLine();
}
Console.WriteLine();
});
void Action()
{
Console.WriteLine($"Before Phase 1 Tid: {Thread.CurrentThread.ManagedThreadId}");
if (Thread.CurrentThread.ManagedThreadId == 1)
{
Thread.Sleep(TimeSpan.FromSeconds(3));
}
barrier.SignalAndWait(); // during the post-phase action, count should be 4 and phase should be 0
Console.WriteLine($"After Phase 1 Tid: {Thread.CurrentThread.ManagedThreadId}");
Console.WriteLine($"Before Phase 2 Tid: {Thread.CurrentThread.ManagedThreadId}");
if (Thread.CurrentThread.ManagedThreadId == 1)
{
Thread.Sleep(TimeSpan.FromSeconds(3));
}
barrier.SignalAndWait(); // during the post-phase action, count should be 8 and phase should be 1
Console.WriteLine($"After Phase 2 Tid: {Thread.CurrentThread.ManagedThreadId}");
Console.WriteLine($"Before Phase 3 Tid: {Thread.CurrentThread.ManagedThreadId}");
if (Thread.CurrentThread.ManagedThreadId == 1)
{
Thread.Sleep(TimeSpan.FromSeconds(3));
}
barrier.SignalAndWait(); // during the post-phase action, count should be 8 and phase should be 1
Console.WriteLine($"After Phase 3 Tid: {Thread.CurrentThread.ManagedThreadId}");
}
Parallel.Invoke(Action, Action, Action);
// It's good form to Dispose() a barrier when you're done with it.
barrier.Dispose();
}
public static void TestThrowException()
{
Console.WriteLine("BarrierTest.TestThrowException Begin");
_tasks = new Task[_participants];
_barrier = new Barrier(_participants, barrier =>
{
Console.WriteLine($"Current phase: {barrier.CurrentPhaseNumber}");
if (barrier.CurrentPhaseNumber == 10)
{
throw new InvalidOperationException("No more phases allowed");
}
});
for (int i = 0; i < _participants; i++)
{
_tasks[i] = Task.Factory.StartNew(num =>
{
var participantNumber = (int)num;
for (int j = 0; j < 10; j++)
{
CreatePlanets(participantNumber);
try
{
_barrier.SignalAndWait();
}
catch (BarrierPostPhaseException bppex)
{
Console.WriteLine(bppex.InnerException.Message);
break;
}
CreateStars(participantNumber);
_barrier.SignalAndWait();
CheckCollisionsBetweenPlanets(participantNumber);
_barrier.SignalAndWait();
CheckCollisionsBetweenStars(participantNumber);
_barrier.SignalAndWait();
RenderCollisions(participantNumber);
_barrier.SignalAndWait();
}
}, i);
}
var finalTask = Task.Factory.ContinueWhenAll(_tasks, tasks =>
{
Task.WaitAll(_tasks);
Console.WriteLine("All the phases were executed.");
_barrier.Dispose();
});
finalTask.Wait();
}
public void BarrierExceptionTest()
{
var barrier = new Barrier(3, barrier1 =>
{
if (barrier1.CurrentPhaseNumber == 2)
{
throw new Exception("phase number 2.");
}
});
var tasks = new Task[3];
for (int i = 0; i < tasks.Length; i++)
{
tasks[i] = Task.Factory.StartNew(() =>
{
Thread.Sleep(100);
Trace.WriteLine($"{Thread.CurrentThread.ManagedThreadId} operation 1.");
barrier.SignalAndWait();
Thread.Sleep(100);
Trace.WriteLine($"{Thread.CurrentThread.ManagedThreadId} operation 2.");
barrier.SignalAndWait();
Thread.Sleep(100);
Trace.WriteLine($"{Thread.CurrentThread.ManagedThreadId} operation 3.");
try
{
barrier.SignalAndWait();
}
catch (BarrierPostPhaseException ex)
{
Trace.WriteLine(ex.Message);
Trace.WriteLine(ex.InnerException.Message);
}
});
}
try
{
Task.WaitAll(tasks);
}
catch (Exception ex)
{
throw ex;
}
finally
{
barrier.Dispose();
}
}
public void Dispose()
{
_isDisposed = true;
_mre.Set();
_mre.Close();
_countEvt.Dispose();
_barrier.SignalAndWait();
CheckAllThreadsFinished();
_barrier.Dispose();
_mre = null;
_workItems = null;
}
public static void RunBarrierTest6_Dispose()
{
Barrier b = new Barrier(1);
b.Dispose();
try
{
b.SignalAndWait();
Assert.True(false, string.Format("BarrierTests: Cancel failed, SignalAndWait didn't throw exceptions after Dispose."));
}
catch (ObjectDisposedException)
{
}
}
public void Run()
{
ThrowIfDisposed();
if (_isRunning)
{
return;
}
_isRunning = true;
_barrier?.Dispose();
_barrier = new Barrier(this.QueueOptions.ConsumeConcurrencyLevel);
foreach (var i in Enumerable.Range(1, this.QueueOptions.ConsumeConcurrencyLevel))
{
this.StartParallel();
}
}
public static void RunBarrierTest10c()
{
for (int j = 0; j < 10; j++)
{
Task[] tasks = new Task[2];
Barrier b = new Barrier(3);
tasks[0] = Task.Run(() => b.SignalAndWait());
tasks[1] = Task.Run(() => b.SignalAndWait());
b.SignalAndWait();
b.Dispose();
GC.Collect();
Task.WaitAll(tasks);
}
}
public void Dispose()
{
if (this.m_partitionIndex == 0)
{
for (int i = 0; i < this.m_sharedBarriers.GetLength(0); i++)
{
for (int j = 0; j < this.m_sharedBarriers.GetLength(1); j++)
{
Barrier barrier = this.m_sharedBarriers[i, j];
if (barrier != null)
{
barrier.Dispose();
}
}
}
}
}
public static void Run()
{
var cts = new System.Threading.CancellationTokenSource();
var ct = cts.Token;
_tasks = new Task[_particapants];
_barrier = new Barrier(_particapants, (barrier) =>
{
Console.WriteLine("Current phase: {0}", barrier.CurrentPhaseNumber);
});
var s1 = new SpinLock(false);
int totalRenders = 0;
for (int i = 0; i < _particapants; i++)
{
_tasks[i] = Task.Factory.StartNew((num) =>
{
var paiticipantNumber = (int)num;
for (int j = 0; j < 10; j++)
{
CreatePlanets(paiticipantNumber);
_barrier.SignalAndWait();
CreateStars(paiticipantNumber);
_barrier.SignalAndWait();
CheckCollisionBetweenPlanets(paiticipantNumber);
_barrier.SignalAndWait();
CheckCollisionBetweenStars(paiticipantNumber);
_barrier.SignalAndWait();
RenderCollisions(paiticipantNumber);
_barrier.SignalAndWait();
Interlocked.Increment(ref totalRenders);
}
}, i, ct);
}
//很多任务完成其工作之后
var finalTask = Task.Factory.ContinueWhenAll(_tasks, (tasks) =>
{
Task.WaitAll(_tasks);
Console.WriteLine("{0} renders were executed.", totalRenders);
_barrier.Dispose();
});
finalTask.Wait();
Console.ReadLine();
}
public static void BarrierCancellationTestsCancelBeforeWait()
{
Barrier barrier = new Barrier(3);
CancellationTokenSource cs = new CancellationTokenSource();
cs.Cancel();
CancellationToken ct = cs.Token;
const int millisec = 100;
TimeSpan timeSpan = new TimeSpan(100);
EnsureOperationCanceledExceptionThrown(
() => barrier.SignalAndWait(ct), ct,
"CancelBeforeWait: An OCE should have been thrown.");
EnsureOperationCanceledExceptionThrown(
() => barrier.SignalAndWait(millisec, ct), ct,
"CancelBeforeWait: An OCE should have been thrown.");
EnsureOperationCanceledExceptionThrown(
() => barrier.SignalAndWait(timeSpan, ct), ct,
"CancelBeforeWait: An OCE should have been thrown.");
barrier.Dispose();
}
public static void RunBarrierTest6_Dispose()
{
Barrier b = new Barrier(1);
b.Dispose();
try
{
b.SignalAndWait();
Assert.True(false, string.Format("BarrierTests: Cancel failed, SignalAndWait didn't throw exceptions after Dispose."));
}
catch (ObjectDisposedException)
{
}
}
public static void RunBarrierTest10c()
{
for (int j = 0; j < 10000; j++)
{
Task[] tasks = new Task[2];
Barrier b = new Barrier(3);
tasks[0] = Task.Run(() => b.SignalAndWait());
tasks[1] = Task.Run(() => b.SignalAndWait());
b.SignalAndWait();
b.Dispose();
GC.Collect();
try
{
Task.WaitAll(tasks);
}
catch
{
Assert.True(false, string.Format("RunBarrierTest10c: Error: Only finished {0} iterations, before an exception was thrown.", j));
}
}
}
public static void RunBarrierTest6_Dispose()
{
Barrier b = new Barrier(1);
b.Dispose();
Assert.Throws<ObjectDisposedException>(() => b.SignalAndWait());
}
public static void RunBarrierTest10c()
{
for (int j = 0; j < 10000; j++)
{
Task[] tasks = new Task[2];
Barrier b = new Barrier(3);
tasks[0] = Task.Run(() => b.SignalAndWait());
tasks[1] = Task.Run(() => b.SignalAndWait());
b.SignalAndWait();
b.Dispose();
GC.Collect();
Task.WaitAll(tasks);
}
}
