How to protect resources that may be used in a multi-threaded or async environment?

by

You can use SemaphoreSlim with 1 as the number of requests. SemaphoreSlim allows to lock in both an async fashion using WaitAsync and the old synchronous way:

await _semphore.WaitAsync()
try
{
    ... use shared resource.
}
finally
{
    _semphore.Release()
}

You can also write your own AsyncLock based on Stephen Toub’s great post Building Async Coordination Primitives, Part 6: AsyncLock. I did it in my application and allowed for both synchronous and asynchronous locks on the same construct.

Usage:

// Async
using (await _asyncLock.LockAsync())
{
    ... use shared resource.
}

// Synchronous
using (_asyncLock.Lock())
{
    ... use shared resource.
}

Implementation:

class AsyncLock
{
    private readonly Task<IDisposable> _releaserTask;
    private readonly SemaphoreSlim _semaphore = new SemaphoreSlim(1, 1);
    private readonly IDisposable _releaser;

    public AsyncLock()
    {
        _releaser = new Releaser(_semaphore);
        _releaserTask = Task.FromResult(_releaser);
    }
    public IDisposable Lock()
    {
        _semaphore.Wait();
        return _releaser;
    }
    public Task<IDisposable> LockAsync()
    {
        var waitTask = _semaphore.WaitAsync();
        return waitTask.IsCompleted
            ? _releaserTask
            : waitTask.ContinueWith(
                (_, releaser) => (IDisposable) releaser,
                _releaser,
                CancellationToken.None,
                TaskContinuationOptions.ExecuteSynchronously,
                TaskScheduler.Default);
    }
    private class Releaser : IDisposable
    {
        private readonly SemaphoreSlim _semaphore;
        public Releaser(SemaphoreSlim semaphore)
        {
            _semaphore = semaphore;
        }
        public void Dispose()
        {
            _semaphore.Release();
        }
    }
}

More Related Contents:

  1. If async-await doesn’t create any additional threads, then how does it make applications responsive?
  2. What is the difference between asynchronous programming and multithreading?
  3. Named Mutex with await
  4. What thread runs the code after the `await` keyword?
  5. Is .GetAwaiter().GetResult(); safe for general use?
  6. SynchronizationLockException on Monitor.Exit when using await
  7. Async thread body loop, It just works, but how?
  8. I thought await continued on the same thread as the caller, but it seems not to
  9. How do I create a custom SynchronizationContext so that all continuations can be processed by my own single-threaded event loop?
  10. Synchronous implementation of interface that returns Task
  11. Async and Await with For Loop [duplicate]
  12. Calling TaskCompletionSource.SetResult in a non blocking manner
  13. Running multiple async tasks and waiting for them all to complete
  14. Calling async method synchronously
  15. Entity Framework async operation takes ten times as long to complete
  16. Task sequencing and re-entracy
  17. Calling async methods from a WCF service
  18. How to wait for async method to complete?
  19. Why use async and return await, when you can return Task directly?
  20. async await return Task
  21. Executing tasks in parallel
  22. Lock (Monitor) internal implementation in .NET
  23. Proper way to start and fire-and-forget asynchronous calls?
  24. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  25. A pattern for self-cancelling and restarting task
  26. How to get awaitable Thread.Sleep?
  27. A pattern to pause/resume an async task?
  28. Queue of async tasks with throttling which supports muti-threading
  29. Using async / await with DataReader ? ( without middle buffers!)
  30. Timeout pattern on task-based asynchronous method in C#

Leave a Comment