public async Task CancellationOnStartForMultithreadedSemaphoreAcquireTest() { SemaphoreAsync sem = new SemaphoreAsync(0, 10); CancellationTokenSource cts = new CancellationTokenSource(); cts.Cancel(); Task[] tasks = Enumerable.Range(1, 10) .Select((n) => { Task <bool> tres = Task.Run(() => { Console.WriteLine("Thread {0}", n); return(sem.AcquireAsync(1, cts.Token)); }); return(tres); }) .ToArray(); await Assert.ThrowsExceptionAsync <TaskCanceledException>(async() => await Task.WhenAll(tasks)); foreach (var t in tasks) { Assert.IsTrue(t.IsCanceled); } }
// construct the blocking queue public BlockingQueueAsync(int capacity) { this.capacity = capacity; this.room = new T[capacity]; this.putIdx = this.takeIdx = 0; this.freeSlots = new SemaphoreAsync(capacity, capacity); this.filledSlots = new SemaphoreAsync(0, capacity); }
public void CancellationOnStartForSemaphoreAcquireTest() { SemaphoreAsync sem = new SemaphoreAsync(1, 2); CancellationTokenSource cts = new CancellationTokenSource(); cts.Cancel(); _ = sem.AcquireAsync(2, cts.Token, 5000).Result; }
// construct the blocking queue public MessageQueue(int capacity) { this.capacity = capacity; this.room = new Message[capacity]; this.putIdx = this.takeIdx = 0; this.freeSlots = new SemaphoreAsync(capacity, capacity); this.filledSlots = new SemaphoreAsync(0, capacity); }
public async Task CancellationOnSemaphoreAcquireTest() { SemaphoreAsync sem = new SemaphoreAsync(1, 2); CancellationTokenSource cts = new CancellationTokenSource(); cts.CancelAfter(2000); await sem.AcquireAsync(2, cts.Token); }
public void SimpleSemaphoreAcquireTest() { SemaphoreAsync sem = new SemaphoreAsync(5, 5); bool res = sem.AcquireAsync(3, CancellationToken.None).Result; Assert.IsTrue(res); bool res1 = sem.AcquireAsync(2, CancellationToken.None, Timeout.Infinite).Result; Assert.IsTrue(res1); }
/** * Test semaphore as a mutual exclusion lock using synchronous acquires. */ private static bool TestSemaphoreAsLockSync() { const int SETUP_TIME = 50; #if (!RUN_CONTINOUSLY) const int RUN_TIME = 10 * 1000; #endif int THREADS = 50; const int MIN_TIMEOUT = 1; const int MAX_TIMEOUT = 50; const int MIN_CANCEL_INTERVAL = 1; const int MAX_CANCEL_INTERVAL = 50; Thread[] tthrs = new Thread[THREADS]; int[] privateCounters = new int[THREADS]; int[] timeouts = new int[THREADS]; int[] cancellations = new int[THREADS]; int issuedInterrupts = 0; int[] sensedInterrupts = new int[THREADS]; int sharedCounter = 0; bool exit = false; ManualResetEventSlim start = new ManualResetEventSlim(); SemaphoreAsync _lock = new SemaphoreAsync(1, 1); /** * Create and start acquirer/releaser threads */ for (int i = 0; i < THREADS; i++) { int tid = i; tthrs[i] = new Thread(() => { Random rnd = new Random(Thread.CurrentThread.ManagedThreadId); start.Wait(); CancellationTokenSource cts = new CancellationTokenSource(rnd.Next(MIN_CANCEL_INTERVAL, MAX_CANCEL_INTERVAL)); do { do { try { if (_lock.Wait(timeout: rnd.Next(MIN_TIMEOUT, MAX_TIMEOUT), cToken: cts.Token)) { break; } timeouts[tid]++; } catch (OperationCanceledException) { cancellations[tid]++; cts.Dispose(); cts = new CancellationTokenSource(rnd.Next(MIN_CANCEL_INTERVAL, MAX_CANCEL_INTERVAL)); } catch (ThreadInterruptedException) { sensedInterrupts[tid]++; } } while (true); try { Thread.Sleep(0); } catch (ThreadInterruptedException) { sensedInterrupts[tid]++; } sharedCounter++; if (THREADS > 1) { if (rnd.Next(100) < 99) { Thread.Yield(); } else { try { Thread.Sleep(rnd.Next(MIN_TIMEOUT, MAX_TIMEOUT)); } catch (ThreadInterruptedException) { sensedInterrupts[tid]++; } } } // release the lock _lock.Release(); privateCounters[tid]++; if (THREADS > 1) { try { if ((privateCounters[tid] % 100) == 0) { Console.Write("[#{0:D2}]", tid); } } catch (ThreadInterruptedException) { sensedInterrupts[tid]++; } } } while (!Volatile.Read(ref exit)); try { Thread.Sleep(10); } catch (ThreadInterruptedException) { sensedInterrupts[tid]++; } }); tthrs[i].Start(); } Thread.Sleep(SETUP_TIME); Stopwatch sw = Stopwatch.StartNew(); start.Set(); Random grnd = new Random(Thread.CurrentThread.ManagedThreadId); int startTime = Environment.TickCount; //... do { Thread.Sleep(grnd.Next(5)); #if SEND_INTERRUPTS if (THREADS > 1) { tthrs[grnd.Next(THREADS)].Interrupt(); issuedInterrupts++; } #endif if (Console.KeyAvailable) { Console.Read(); break; } #if RUN_CONTINOUSLY } while (true); #else } while (Environment.TickCount - startTime < RUN_TIME);
/** * Construct the blocking queue */ public BlockingQueueAsync(int capacity) { queue = new ConcurrentQueue <T>(); freeSlots = new SemaphoreAsync(capacity, capacity); filledSlots = new SemaphoreAsync(0, capacity); }
public async Task TimeoutSemaphoreAcquireTest() { SemaphoreAsync sem = new SemaphoreAsync(1, 2); await sem.AcquireAsync(2, CancellationToken.None, 2000); }
/** * Constructor */ public MessageQueueAsync(int capacity = int.MaxValue) { queue = new ConcurrentQueue <T>(); freeSlots = new SemaphoreAsync(capacity, capacity); filledSlots = new SemaphoreAsync(0, capacity); }