Semaphores are a multi-threading locking mechanism that ensure that only a limited number of threads are running on a given resource. Mutexes are a special case where that limited number is one.
Asynchronous programming has a lot in common with (and sometimes to do with) multi-threaded programming, even though it's not inherently multi-threaded itself.
The following code creates ten tasks that simply wait for a second and log their start and end.
All of them are executed on only one thread (I assume a proper synchronization context maintenance is in place as is the case in WPF, for instance).
So even though there's only one thread we have "parallel" tasks and there can be use cases where one would want to limit access to a resource to only a few or one of those tasks. (For example, to limit parallel network requests.)
It appears there's need for an "async semaphore" - a concept that locks out not threads but asynchronous continuations.
I've implemented such a semaphore to check whether it really does make sense and to spell out what exactly I mean.
My question would be: Is this thing available already, ideally in the .NET framework itself? I couldn't find anything, although it seems to me that it should exist.
So here's the code (LINQPad share here):
async void Main() { // Necessary in LINQPad to ensure a single thread. // Other environments such as WPF do this for you. SynchronizationContext.SetSynchronizationContext( new DispatcherSynchronizationContext()); var tasks = Enumerable.Range(1, 10).Select(SampleWork).ToArray(); await Task.WhenAll(tasks); "All done.".Dump(); } AsyncSemaphore commonSemaphore = new AsyncSemaphore(4); async Task SampleWork(Int32 i) { using (await commonSemaphore.Acquire()) { $"Beginning work #{i} {Thread.CurrentThread.ManagedThreadId}".Dump(); await Task.Delay(TimeSpan.FromSeconds(1)); $"Finished work #{i} {Thread.CurrentThread.ManagedThreadId}".Dump(); } } public class AsyncSemaphore { Int32 maxTasks; Int32 currentTasks; ReleasingDisposable release; Queue<TaskCompletionSource<Object>> continuations = new Queue<TaskCompletionSource<Object>>(); public AsyncSemaphore(Int32 maxTasks = 1) { this.maxTasks = maxTasks; release = new ReleasingDisposable(this); } public async Task<IDisposable> Acquire() { ++currentTasks; if (currentTasks > maxTasks) { var tcs = new TaskCompletionSource<Object>(); continuations.Enqueue(tcs); await tcs.Task; } return release; } void Release() { --currentTasks; if (continuations.Count > 0) { var tcs = continuations.Dequeue(); tcs.SetResult(null); } } class ReleasingDisposable : IDisposable { AsyncSemaphore self; public ReleasingDisposable(AsyncSemaphore self) => this.self = self; public void Dispose() => self.Release(); } } I get this output:
Beginning work #1 1 Beginning work #2 1 Beginning work #3 1 Beginning work #4 1 Finished work #4 1 Finished work #3 1 Finished work #2 1 Finished work #1 1 Beginning work #5 1 Beginning work #6 1 Beginning work #7 1 Beginning work #8 1 Finished work #5 1 Beginning work #9 1 Finished work #8 1 Finished work #7 1 Finished work #6 1 Beginning work #10 1 Finished work #9 1 Finished work #10 1 All done. So indeed, I have at most 4 tasks running, and all are running on the same thread.
SemaphoreSlim? It has a WaitOneAsync method.SemaphoreSlimclass is a semaphore for multiple threads. My question is a about an analogous single-threaded concept of semaphores.SemaphoreSlimworks just as well on a single thread. If the same thread callsWaitAsyncmultiple times in succession, it will keep decrementing the counter until it hits 0, then suspend execution until aReleaseis called. See this answer.SemaphoreSlimdoes not guarantee FIFO, although it might provide it when used on a single thread.