public static async Task ExclusiveLock() { using (var syncRoot = new AsyncExclusiveLock()) using (var @lock = AsyncLock.Exclusive(syncRoot)) { var holder = await @lock.TryAcquire(CancellationToken.None); if (holder) { } else { throw new Exception(); } True(syncRoot.IsLockHeld); holder.Dispose(); False(syncRoot.IsLockHeld); holder = await @lock.Acquire(CancellationToken.None); True(syncRoot.IsLockHeld); holder.Dispose(); False(syncRoot.IsLockHeld); } }
public static void CallDisposeTwice() { var @lock = new AsyncExclusiveLock(); @lock.Dispose(); True(@lock.DisposeAsync().IsCompletedSuccessfully); }
public static void FailFastLock() { using var @lock = new AsyncExclusiveLock(); True(@lock.TryAcquire()); True(@lock.IsLockHeld); False(@lock.TryAcquire()); @lock.Release(); }
public static async Task TrivialLock() { using var @lock = new AsyncExclusiveLock(); True(await @lock.TryAcquireAsync(TimeSpan.FromMilliseconds(10))); False(await @lock.TryAcquireAsync(TimeSpan.FromMilliseconds(100))); await ThrowsAsync <TimeoutException>(() => @lock.AcquireAsync(TimeSpan.FromMilliseconds(100))); @lock.Release(); True(await @lock.TryAcquireAsync(TimeSpan.FromMilliseconds(100))); }
public static void GracefulShutdown() { using var @lock = new AsyncExclusiveLock(); True(@lock.TryAcquire()); var task = @lock.DisposeAsync(); False(task.IsCompleted); @lock.Release(); True(task.IsCompletedSuccessfully); Throws <ObjectDisposedException>(() => @lock.TryAcquire()); }
public static void CancelSuspendedCallers() { using var @lock = new AsyncExclusiveLock(); True(@lock.TryAcquire()); var waitNode = @lock.AcquireAsync(CancellationToken.None); False(waitNode.IsCompleted); Throws <ArgumentOutOfRangeException>(() => @lock.CancelSuspendedCallers(new CancellationToken(false))); @lock.CancelSuspendedCallers(new CancellationToken(true)); True(waitNode.IsCompleted); False(waitNode.IsCompletedSuccessfully); True(waitNode.IsCanceled); }
public static void GracefulShutdown2() { using var @lock = new AsyncExclusiveLock(); True(@lock.TryAcquire()); var task = @lock.DisposeAsync(); False(task.IsCompleted); var acquisition = @lock.AcquireAsync(CancellationToken.None); False(acquisition.IsCompleted); @lock.Release(); True(task.IsCompletedSuccessfully); True(acquisition.IsFaulted); Throws <ObjectDisposedException>(acquisition.GetAwaiter().GetResult); }
public static async Task ConcurrentLock() { using var are = new AutoResetEvent(false); using var @lock = new AsyncExclusiveLock(); await @lock.AcquireAsync(TimeSpan.Zero); var task = new TaskCompletionSource <bool>(); ThreadPool.QueueUserWorkItem(async state => { False(await @lock.TryAcquireAsync(TimeSpan.FromMilliseconds(10))); True(ThreadPool.QueueUserWorkItem(static ev => ev.Set(), are, false)); await @lock.AcquireAsync(DefaultTimeout); @lock.Release(); task.SetResult(true); });
public static async Task ConcurrentLock() { using (var are = new AutoResetEvent(false)) using (var @lock = new AsyncExclusiveLock()) { await @lock.Acquire(TimeSpan.Zero); var task = new TaskCompletionSource <bool>(); ThreadPool.QueueUserWorkItem(async state => { False(await @lock.TryAcquire(TimeSpan.FromMilliseconds(10))); True(ThreadPool.QueueUserWorkItem(ev => ev.Set(), are, false)); await @lock.Acquire(InfiniteTimeSpan); @lock.Release(); task.SetResult(true); }); True(are.WaitOne(TimeSpan.FromMinutes(1))); @lock.Release(); await task.Task; } }
static bool CheckLockState(AsyncExclusiveLock obj) => obj.IsLockHeld;
/// <summary> /// Wraps exclusive lock into the unified representation of asynchronous lock. /// </summary> /// <param name="lock">The lock object to be wrapped.</param> /// <returns>Exclusive asynchronous lock.</returns> public static AsyncLock Exclusive(AsyncExclusiveLock @lock) => new AsyncLock(@lock ?? throw new ArgumentNullException(nameof(@lock)), Type.Exclusive, false);
public static void DisposeAsyncCompletedAsynchronously() { using var @lock = new AsyncExclusiveLock(); True(@lock.DisposeAsync().IsCompletedSuccessfully); }