public static void RunSpinLockTest0_Enter(int threadsCount, bool enableThreadIDs) { // threads array Task[] threads = new Task[threadsCount]; //spinlock object SpinLock slock = new SpinLock(enableThreadIDs); // succeeded threads counter int succeeded = 0; // Semaphore used to make sure that there is no other threads in the critical section SemaphoreSlim semaphore = new SemaphoreSlim(1, 1); for (int i = 0; i < threadsCount; i++) { threads[i] = Task.Run(delegate () { bool lockTaken = false; try { slock.Enter(ref lockTaken); //use semaphore to make sure that no other thread inside the critical section if (!semaphore.Wait(0)) { // This mean that there is another thread in the critical section return; } succeeded++; if (slock.IsThreadOwnerTrackingEnabled && !slock.IsHeldByCurrentThread) { // lock is obtained successfully succeeded--; } } catch { // decrement the count in case of exception succeeded--; } finally { semaphore.Release(); if (lockTaken) { slock.Exit(); } } }); } // wait all threads for (int i = 0; i < threadsCount; i++) { threads[i].Wait(); } // count must be equal to the threads count Assert.Equal(threadsCount, succeeded); }
public static void EnterExit() { var sl = new SpinLock(); Assert.True(sl.IsThreadOwnerTrackingEnabled); for (int i = 0; i < 4; i++) { Assert.False(sl.IsHeld); Assert.False(sl.IsHeldByCurrentThread); bool lockTaken = false; if (i % 2 == 0) sl.Enter(ref lockTaken); else sl.TryEnter(ref lockTaken); Assert.True(lockTaken); Assert.True(sl.IsHeld); Assert.True(sl.IsHeldByCurrentThread); Task.Factory.StartNew(() => { Assert.True(sl.IsHeld); Assert.False(sl.IsHeldByCurrentThread); }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default).GetAwaiter().GetResult(); sl.Exit(); } }
/// <summary> /// 获取新的连接出去的客户端 /// </summary> /// <returns></returns> internal ClientSocketManager Slice() { ClientSocketManager returnSocket = null; m_LockSliceSocket.Enter(); { if (m_IsNeedSlice == true) { m_IsNeedSlice = false; returnSocket = m_ClientSocketManager; } } m_LockSliceSocket.Exit(); return(returnSocket); }
public void SemanticCorrectnessTest() { _sl = new SpinLock(false); var taken = false; var taken2 = false; _sl.Enter(ref taken); Assert.IsTrue(taken, "#1"); _sl.TryEnter(ref taken2); Assert.IsFalse(taken2, "#2"); _sl.Exit(); _sl.TryEnter(ref taken2); Assert.IsTrue(taken2, "#3"); }
public static void Test() { lock (_lock) { } bool lockTaken = false; try { _spinLock.Enter(ref lockTaken); } finally { if (lockTaken) { _spinLock.Exit(); } } }
/// <summary> /// Test SpinLock.TryEnter(Timespan) by generating random timespan milliseconds /// </summary> /// <param name="threadsCount">Number of threads that call enter/exit</param> /// <returns>True if succeeded, false otherwise</returns> private static void RunSpinLockTest2_TryEnter(int threadsCount, bool enableThreadIDs) { for (int j = 0; j < 2; j++) { bool useMemoryBarrier = j == 0; Task[] threads = new Task[threadsCount]; SpinLock slock = new SpinLock(enableThreadIDs); int succeeded = 0; int failed = 0; // Run threads for (int i = 0; i < threadsCount; i++) { threads[i] = new Task(delegate(object x) { // Generate random timespan bool lockTaken = false; TimeSpan time = TimeSpan.FromMilliseconds(20); slock.TryEnter(time, ref lockTaken); if (lockTaken) { // add some delay in the critical section Task.WaitAll(Task.Delay(15)); Interlocked.Increment(ref succeeded); slock.Exit(useMemoryBarrier); } else { // Failed to get the lock within the timeout Interlocked.Increment(ref failed); } }, i); threads[i].Start(TaskScheduler.Default); } // Wait all threads for (int i = 0; i < threadsCount; i++) { threads[i].Wait(); } // succeeded + failed must be equal to the threads count. if (succeeded + failed != threadsCount) { Assert.True(false, string.Format("SpinLock.TryEnter() failed, actual count: " + (succeeded + failed) + " expected :" + threadsCount)); } } }
public int Next() { bool lockTaken = false; try { _spinLock.Enter(ref lockTaken); return(_random.Next()); } finally { if (lockTaken) { _spinLock.Exit(); } } }
public void DoLocked(Action action) { var lockTaken = false; try { spinLock.Enter(ref lockTaken); action(); } finally { if (lockTaken) { spinLock.Exit(); } } }
public override void Open() { EnterLocked(ref OpenLock, "Open"); try { if (IsOpen) { throw new Exception("Result listener is already open"); } IsOpen = true; base.Open(); } finally { OpenLock.Exit(false); } }
public void Atom_Enter() { double d_org = 2.2d; double d_new = 1.1d; double d_old; d_old = Interlocked.Exchange(ref d_org, d_new); SpinLock spinL = new SpinLock(); bool r = true; spinL.Enter(ref r); spinL.Exit(); SpinWait spin = new SpinWait(); spin.SpinOnce(); }
/// <summary>Acquires the lock and safely releases on dispose</summary> public static Scope Lock(this SpinLock sl) { return(Scope.Create( () => { bool got_lock = false; sl.Enter(ref got_lock); return got_lock; }, gl => { if (gl) { sl.Exit(); } })); }
static void Bar(SampleClass m) { bool lockTaken = false; try { _spinLock.Enter(ref lockTaken); _queue.Enqueue(m); } finally { if (lockTaken) { _spinLock.Exit(false); } } }
private void InvokeLockedInternal(Action action) { bool lockTaken = false; try { _lock.Enter(ref lockTaken); action(); } finally { if (lockTaken) { _lock.Exit(); } } }
static void Main(string[] args) { // create the bank account instance BankAccount account = new BankAccount(); // create the spinlock SpinLock spinlock = new SpinLock(); // create an array of tasks Task[] tasks = new Task[10]; for (int i = 0; i < 10; i++) { // create a new task tasks[i] = new Task(() => { // enter a loop for 1000 balance updates for (int j = 0; j < 1000; j++) { bool lockAcquired = false; try { spinlock.Enter(ref lockAcquired); // update the balance account.Balance = account.Balance + 1; } finally { if (lockAcquired) { spinlock.Exit(); } } } }); // start the new task tasks[i].Start(); } // wait for all of the tasks to complete Task.WaitAll(tasks); // write out the counter value Console.WriteLine("Expected value {0}, Balance: {1}", 10000, account.Balance); // wait for input before exiting Console.WriteLine("Press enter to finish"); Console.ReadLine(); }
/// <summary> /// Test SpinLock.TryEnter() by launching n threads, each one calls TryEnter, the succeeded threads increment /// a counter variable and failed threads increment failed variable, count + failed must be equal to n /// </summary> /// <param name="threadsCount">Number of threads that call enter/exit</param> /// <returns>True if succeeded, false otherwise</returns> private static bool RunSpinLockTest1_TryEnter(int threadsCount, bool enableThreadIDs) { TestHarness.TestLog("SpinLock.TryEnter(" + threadsCount + " threads)"); Thread[] threads = new Thread[threadsCount]; SpinLock slock = new SpinLock(enableThreadIDs); int succeeded = 0; int failed = 0; // Run threads for (int i = 0; i < threadsCount; i++) { threads[i] = new Thread(delegate() { bool lockTaken = false; slock.TryEnter(ref lockTaken); if (lockTaken) { // Increment succeeded counter Interlocked.Increment(ref succeeded); slock.Exit(); } else { // Increment failed counter Interlocked.Increment(ref failed); } }); threads[i].Start(); } // Wait all threads for (int i = 0; i < threadsCount; i++) { threads[i].Join(); } // succeeded + failed must be equal to the threads count. if (succeeded + failed != threadsCount) { TestHarness.TestLog("SpinLock.TryEnter() failed, actual count: " + (succeeded + failed) + " expected :" + threadsCount); return(false); } TestHarness.TestLog("SpinLock.TryEnter() passed."); return(true); }
public bool Execute(Time tripStart, int modeIndex, float expansionFactor, Activity activity) { var modes = Parent.Modes; if (StartTime <= tripStart && tripStart < EndTime) { bool taken = false; WriteLock.Enter(ref taken); GetPurposeCount(activity)[modeIndex] += expansionFactor; if (taken) { WriteLock.Exit(true); } return(true); } return(false); }
public static void SafeWork(this SpinLock spinLock, Action action) { bool lockTaken = false; try { spinLock.Enter(ref lockTaken); action(); } finally { if (lockTaken) { spinLock.Exit(); } } }
private static void DoWork() { SpinLock spinLock = new SpinLock(); bool isGetLock = false; //是否已获得了锁 try { spinLock.Enter(ref isGetLock); } finally { if (isGetLock) { spinLock.Exit(); } } }
public void Add(decimal value) { bool acquiredLock = false; try { _lock.Enter(ref acquiredLock); _total += value; } finally { if (acquiredLock) { _lock.Exit(); } } }
/// <summary>Gets the builder's task with appropriate synchronization.</summary> internal Task <int> GetTaskSafe() { bool lockTaken = false; try { BuilderTaskLock.Enter(ref lockTaken); return(Builder.Task); } finally { if (lockTaken) { BuilderTaskLock.Exit(useMemoryBarrier: false); } } }
static void Main(string[] args) { bool Locked = false; try { MySpinLock.Enter(ref Locked); //Work that requires lock would be done here } finally { if (Locked) { MySpinLock.Exit(); } } }
private void SetPrintedError() { bool gotLock = false; try { printedErrLock.Enter(ref gotLock); printedErr = true; } finally { if (gotLock) { printedErrLock.Exit(); } } }
public static void DoLock(this SpinLock locker, Action action, int maximumRetryCount = 4096) { var retryCount = 0; var acquired = false; while (!acquired) { locker.Enter(ref acquired); if (++retryCount > maximumRetryCount) { throw new InvalidOperationException("lock timeout"); } } action(); locker.Exit(); }
public int AddBytes(int count) { bool lockTaken = false; try { _thisLock.Enter(ref lockTaken); return(_bytesLeft -= count); } finally { if (lockTaken) { _thisLock.Exit(false); } } }
/// <summary> /// 空转锁,等待锁的线程并不放弃cpu,而是空转。 /// </summary> /// <param name="action"></param> public void Spinlock(Action action) { bool lockTaken = false; try { spinLock.Enter(ref lockTaken); action(); } finally { if (lockTaken) { spinLock.Exit(); } } }
/// <summary> /// Locks are made for each correlation id. We don't want to lock threads that handle /// a client that is not disconnected /// </summary> public static object GetLock(string correlationId) { bool lockTacken = false; try { gate.Enter(ref lockTacken); return(_locks.GetOrAdd(correlationId, _ => new object())); } finally { if (lockTacken) { gate.Exit(); } } }
private void SetDaysOff() { Parallel.For(0, _populationSize, (i) => { Individual individual = new Individual { Dna = new IAllel[_totalNumberOfDoctors, DateTime.DaysInMonth(_date.Year, _date.Month)] }; for (int j = 0; j < _totalNumberOfDoctors; j++) { int index = j; var daysOff = _daysOff.FindAll(d => d.UserId == _doctorIds[index]).Select(d => d.Date.Day).ToList(); if (daysOff.Count == 0) { continue; } else { for (int k = 0; k < DateTime.DaysInMonth(_date.Year, _date.Month); k++) { if (daysOff.Contains(k + 1)) { individual.Dna[j, k] = Allel.DayOff; } } } } bool lockTaken = false; try { _spinLock.Enter(ref lockTaken); _individuals.Add(individual); } finally { if (lockTaken) { _spinLock.Exit(); } } }); }
private static void ThreadProc(object state) { bool lockTaken = false; Console.WriteLine($"Thread{Thread.CurrentThread.ManagedThreadId} 等候取得 SpinLock 擁有權 Enter"); spinLock.Enter(ref lockTaken); Console.WriteLine($"Thread{Thread.CurrentThread.ManagedThreadId} @ 已經取得 SpinLock 擁有權"); Console.WriteLine($"模擬 Thread{Thread.CurrentThread.ManagedThreadId} 執行專屬獨享的1秒時間的工作"); Thread.Sleep(1000); Console.WriteLine($"Thread{Thread.CurrentThread.ManagedThreadId} 準備要釋放 SpinLock 擁有權"); spinLock.Exit(); Console.WriteLine($"Thread{Thread.CurrentThread.ManagedThreadId} # 已經要釋放 SpinLock 擁有權 Exit"); }
private void UpdateWithSpinLock(Data d, int i) { bool lockTaken = false; try { _spinlock.Enter(ref lockTaken); _queue.Enqueue(d); } finally { if (lockTaken) { _spinlock.Exit(false); } } }
/// <summary> /// Sends messages to targets. /// </summary> protected override void Process() { bool processed; do { ForceProcessing = false; bool lockTaken = false; try { firstItemLock.Enter(ref lockTaken); T item; if (!Store.TryPeek(out item)) { break; } if (!targets.HasCurrentItem) { targets.SetCurrentItem(item); } if (reservedForTargetBlock != null) { break; } processed = targets.OfferItemToTargets(); if (processed) { Outgoing.TryTake(out item); DecreaseCounts(item); FirstItemChanged(); } } finally { if (lockTaken) { firstItemLock.Exit(); } } } while (processed); IsProcessing.Value = false; // to guard against race condition if (ForceProcessing && reservedForTargetBlock == null) { EnsureProcessing(); } VerifyCompleteness(); }
public void EnterExclusive(T id) { bool taken = false; _spinLock.Enter(ref taken); try { if (ExclusiveLockTakenBy(id)) { throw new InvalidOperationException("Recursion is not allowed"); } if (SharedLockTakenBy(id)) { throw new InvalidOperationException("Cannot take shared lock after the exclusive was already taken."); } for (;;) { if (_flags.CanTakeExclusive()) { // from now on all others that try to enter this lock will have to wait _flags.SetExclusiveFlag(); break; } // at any point in time other thread can take the upgradeable lock // so it is better to perform the check here, while within the spinlock if (UpgradeableLockTakenBy(id)) { // only the upgradeable lock (with this id) is taken, it is safe // to upgrade it _flags.SetExclusiveFlag(); break; } // lock is taken, we have to wait SpinWait(); } } finally { _spinLock.Exit(); } // we are protected here, id for exit can be set. _exclusiveOwnerId = id; }
/// <summary> /// 显示教师列表 /// </summary> /// <param name="me"></param> public static void DisplayTeacherList(this UserCore me) { if (UserRepository.TeacherLibrary.Count > 0) { var sLock = new SpinLock(); bool isWhite = true; WriteLine($"{"Name",-10}{"Account",-10}{"UserType",-10}{"Sex",-7}{"Age",-5}{"CreatedTime",-20}{"Since",-7}"); Parallel.For(0, UserRepository.TeacherLibrary.Count, index => { bool hasLock = false; sLock.Enter(ref hasLock); if (hasLock) { try { ConsoleColor bg = isWhite ? ConsoleColor.White : ConsoleColor.Black; ConsoleColor fg = isWhite ? ConsoleColor.Black : ConsoleColor.White; PrintColorMsg($"{UserRepository.TeacherLibrary[index].Name,-10}", bg, ConsoleColor.DarkYellow); PrintColorMsg($"{UserRepository.TeacherLibrary[index].Account,-10}" + $"{UserRepository.TeacherLibrary[index].UserType,-10}" + $"{UserRepository.TeacherLibrary[index].Sex,-7}" + $"{UserRepository.TeacherLibrary[index].Age,-5}" + $"{UserRepository.TeacherLibrary[index].CreatedTime,-20}" + $"{UserRepository.TeacherLibrary[index].YearsOfProfessional,-7}", bg, fg); WriteLine(); isWhite = !isWhite; } finally { sLock.Exit(); } } else { WriteLine("获取锁超时"); } }); } else { DisplayTheInformationOfErrorCode(ErrorCode.NoDisplayableInformation); } }
/// <summary> /// Test TryEnter invalid cases /// </summary> /// <returns>True if succeeded, false otherwise</returns> private static void RunSpinLockTest3_TryEnter(bool enableThreadIDs) { Exception exception = null; SpinLock slock = new SpinLock(enableThreadIDs); bool lockTaken = false; #region Recursive lock if (enableThreadIDs) // only valid if thread IDs are on { // Test recursive locks slock.Enter(ref lockTaken); try { if (lockTaken) { bool dummy = false; // reacquire the lock slock.Enter(ref dummy); } } catch (Exception ex) { // LockRecursionException must be thrown exception = ex; } if (lockTaken) { slock.Exit(); if (exception == null || exception.GetType() != typeof(LockRecursionException)) { Assert.True(false, string.Format("SpinLock.TryEnter() failed, recursive locks without exception")); } if (slock.IsHeldByCurrentThread) { Assert.True(false, string.Format("SpinLock.TryEnter() failed, IsHeld is true after calling Exit")); } } else { Assert.True(false, string.Format("LockRecursionException was not thrown?")); } } #endregion #region timeout > int.max // Test invalid argument handling, too long timeout exception = null; try { lockTaken = false; slock.TryEnter(TimeSpan.MaxValue, ref lockTaken); } catch (Exception ex) { exception = ex; } if (exception == null || exception.GetType() != typeof(ArgumentOutOfRangeException)) { Assert.True(false, string.Format(@"SpinLock.TryEnter() failed, timeout.Totalmilliseconds > int.maxValue without throwing ArgumentOutOfRangeException " + exception)); } #endregion #region Timeout > int.max // Test invalid argument handling, timeout < -1 exception = null; try { lockTaken = false; slock.TryEnter(-2, ref lockTaken); } catch (Exception ex) { exception = ex; } if (exception == null || exception.GetType() != typeof(ArgumentOutOfRangeException)) { Assert.True(false, string.Format(@"SpinLock.TryEnter() failed, timeout < -1 without throwing ArgumentOutOfRangeException")); } #endregion }
/// <summary> /// Test SpinLock.TryEnter(Timespan) by generating random timespan milliseconds /// </summary> /// <param name="threadsCount">Number of threads that call enter/exit</param> /// <returns>True if succeeded, false otherwise</returns> private static void RunSpinLockTest2_TryEnter(int threadsCount, bool enableThreadIDs) { for (int j = 0; j < 2; j++) { bool useMemoryBarrier = j == 0; Task[] threads = new Task[threadsCount]; SpinLock slock = new SpinLock(enableThreadIDs); int succeeded = 0; int failed = 0; // Run threads for (int i = 0; i < threadsCount; i++) { threads[i] = new Task(delegate (object x) { // Generate random timespan bool lockTaken = false; TimeSpan time = TimeSpan.FromMilliseconds(20); slock.TryEnter(time, ref lockTaken); if (lockTaken) { // add some delay in the critical section Task.WaitAll(Task.Delay(15)); Interlocked.Increment(ref succeeded); slock.Exit(useMemoryBarrier); } else { // Failed to get the lock within the timeout Interlocked.Increment(ref failed); } }, i); threads[i].Start(TaskScheduler.Default); } // Wait all threads for (int i = 0; i < threadsCount; i++) { threads[i].Wait(); } // succeeded + failed must be equal to the threads count. if (succeeded + failed != threadsCount) { Assert.True(false, string.Format("SpinLock.TryEnter() failed, actual count: " + (succeeded + failed) + " expected :" + threadsCount)); } } }
public static void RunSpinLockTest1_TryEnter(int threadsCount, bool enableThreadIDs) { for (int j = 0; j < 2; j++) { bool useMemoryBarrier = j == 0; Task[] threads = new Task[threadsCount]; SpinLock slock = new SpinLock(enableThreadIDs); int succeeded = 0; int failed = 0; // Run threads for (int i = 0; i < threadsCount; i++) { threads[i] = Task.Run(delegate () { bool lockTaken = false; slock.TryEnter(ref lockTaken); if (lockTaken) { // Increment succeeded counter Interlocked.Increment(ref succeeded); slock.Exit(useMemoryBarrier); } else { // Increment failed counter Interlocked.Increment(ref failed); } }); } // Wait all threads for (int i = 0; i < threadsCount; i++) { threads[i].Wait(); } // succeeded + failed must be equal to the threads count. Assert.Equal(threadsCount, succeeded + failed); } }
/// <summary> /// Test TryEnter invalid cases /// </summary> /// <returns>True if succeeded, false otherwise</returns> private static void RunSpinLockTest3_TryEnter(bool enableThreadIDs) { SpinLock slock = new SpinLock(enableThreadIDs); bool lockTaken = false; #region Recursive lock if (enableThreadIDs) // only valid if thread IDs are on { // Test recursive locks slock.Enter(ref lockTaken); Assert.True(lockTaken); Assert.Throws<LockRecursionException>(() => { bool dummy = false; slock.Enter(ref dummy); }); slock.Exit(); Assert.False(slock.IsHeldByCurrentThread); } #endregion #region timeout > int.max // Test invalid argument handling, too long timeout Assert.Throws<ArgumentOutOfRangeException>(() => { bool lt = false; slock.TryEnter(TimeSpan.MaxValue, ref lt); }); #endregion timeout > int.max #region Timeout > int.max // Test invalid argument handling, timeout < -1 Assert.Throws<ArgumentOutOfRangeException>(() => { bool lt = false; slock.TryEnter(-2, ref lt); }); #endregion Timeout > int.max }
/// <summary> /// Test Exit /// </summary> /// <returns>True if succeeded, false otherwise</returns> private static void RunSpinLockTest4_Exit(bool enableThreadIDs) { Exception exception = null; SpinLock slock = new SpinLock(enableThreadIDs); bool lockTaken = false; slock.Enter(ref lockTaken); slock.Exit(); if (enableThreadIDs) { if (slock.IsHeldByCurrentThread) { Assert.True(false, string.Format("SpinLock.Exit() failed, IsHeld is true after calling Exit")); } } else { if (slock.IsHeld) { Assert.True(false, string.Format("SpinLock.Exit() failed, IsHeld is true after calling Exit")); } } for (int i = 0; i < 2; i++) { bool useBarrier = i == 0; // Calling Exit without owning the lock try { slock.Exit(useBarrier); } catch (Exception ex) { // SynchronizationLockException must be thrown exception = ex; } } if (enableThreadIDs) { if (exception == null || exception.GetType() != typeof(SynchronizationLockException)) { Assert.True(false, string.Format(@"SpinLock.Exit() failed, calling Exit without owning the lock")); } } }
/// <summary> /// Test Exit /// </summary> /// <returns>True if succeeded, false otherwise</returns> private static void RunSpinLockTest4_Exit(bool enableThreadIDs) { SpinLock slock = new SpinLock(enableThreadIDs); bool lockTaken = false; slock.Enter(ref lockTaken); slock.Exit(); if (enableThreadIDs) { Assert.False(slock.IsHeldByCurrentThread); Assert.Throws<SynchronizationLockException>(() => slock.Exit(true)); Assert.Throws<SynchronizationLockException>(() => slock.Exit(false)); } else { Assert.False(slock.IsHeld); } }
/// <summary> /// Test SpinLock.TryEnter() by launching n threads, each one calls TryEnter, the succeeded threads increment /// a counter variable and failed threads increment failed variable, count + failed must be equal to n /// </summary> /// <param name="threadsCount">Number of threads that call enter/exit</param> /// <returns>True if succeeded, false otherwise</returns> private static void RunSpinLockTest1_TryEnter(int threadsCount, bool enableThreadIDs) { for (int j = 0; j < 2; j++) { bool useMemoryBarrier = j == 0; Task[] threads = new Task[threadsCount]; SpinLock slock = new SpinLock(enableThreadIDs); int succeeded = 0; int failed = 0; // Run threads for (int i = 0; i < threadsCount; i++) { threads[i] = Task.Run(delegate () { bool lockTaken = false; slock.TryEnter(ref lockTaken); if (lockTaken) { // Increment succeeded counter Interlocked.Increment(ref succeeded); slock.Exit(useMemoryBarrier); } else { // Increment failed counter Interlocked.Increment(ref failed); } }); } // Wait all threads for (int i = 0; i < threadsCount; i++) { threads[i].Wait(); } // succeeded + failed must be equal to the threads count. if (succeeded + failed != threadsCount) { Assert.True(false, string.Format("SpinLock.TryEnter() failed, actual count: " + (succeeded + failed) + " expected :" + threadsCount)); } } }
public static void RunSpinLockTest2_TryEnter(int threadsCount, bool enableThreadIDs) { for (int j = 0; j < 2; j++) { bool useMemoryBarrier = j == 0; Task[] threads = new Task[threadsCount]; SpinLock slock = new SpinLock(enableThreadIDs); int succeeded = 0; int failed = 0; // Run threads for (int i = 0; i < threadsCount; i++) { threads[i] = new Task(delegate (object x) { // Generate random timespan bool lockTaken = false; TimeSpan time = TimeSpan.FromMilliseconds(20); slock.TryEnter(time, ref lockTaken); if (lockTaken) { // add some delay in the critical section Task.WaitAll(Task.Delay(15)); Interlocked.Increment(ref succeeded); slock.Exit(useMemoryBarrier); } else { // Failed to get the lock within the timeout Interlocked.Increment(ref failed); } }, i, CancellationToken.None, TaskCreationOptions.LongRunning); threads[i].Start(TaskScheduler.Default); } // Wait all threads for (int i = 0; i < threadsCount; i++) { threads[i].Wait(); } // succeeded + failed must be equal to the threads count. Assert.Equal(threadsCount, succeeded + failed); } }