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);
}
