How to make await async functions thread safe?

Question

0.00/5 (No votes)

See more:

Hi
Let's say you have a function like:

C#

public class MyClass
{
    //Asume that this for some reason needs to be a member variable
    private int count=0;  
    
    public async Task<int> GetCount()
    {
        ++count;
        
        //Could be some real work to do in a method that is declared async
        await Task.Delay(1); 

        return count;
    }
}

If you make an instance of MyClass called myInstanceMyClass and calls

C#

myInstanceMyClass.GetCount()

on two different threads like thread1 and thread2 (using the same instance) then the result could be 1 and 2 or 2 and 2 right? Maybe just before thread1 return the count then thread2 could execute the ++count and then both threads could return 2 in myInstanceMyClass.GetCount().

I cannot make a lock because this gives a compile error:

C#

public async Task<int> GetCount()
{
    lock(myObject) //Gives compile error because of await inside the lock
    {
        ++count;
    
        //Could be some real work to do in a method that is declared async
        await Task.Delay(1);
    
        return count;
    }
}

So what can I do to make the async function GetCount() thread safe?

If the async GetCount() was writing the result to a file on the harddisk then maybe thread1 and thread2 could try to access the file at the same time. What can be done to solve this problem when the filewriting must be done inside an async function and lock() therefore cannot be used?

I can see on Google that someone uses some thirdparty projects to make some kind of

C#

using(var x= instance.Thirdparty()){... only 1 thread can go here at a time...}

but I cannot belive that we have to use thirdparty code to get the functionality that a lock() would give in a case with no await/async call. Are there any official recommendations from Microsoft? Or should we use some kind of programming pattern to "work around" the "await-lock"-problem?

Posted 21-Jan-16 3:01am

Henrik R L

Updated 21-Jan-16 3:03am

v3

Add a Solution

Comments

F-ES Sitecore 21-Jan-16 9:30am

Can't you make the calling code thread safe rather than the method itself? ie put locks around where it might call the method.

Afzaal Ahmad Zeeshan 21-Jan-16 9:35am

Exactly!

Henrik R L 21-Jan-16 9:47am

Hi
I think the calling code must make the call with "await Function" and then you will again have a compile error when making a lock in the calling code.

2 solutions

Solution 1

Because as per C#, it is illegal to do so.

Quote[^]:
An await expression cannot be used in a synchronous function, in a query expression, in the catch or finally block of an exception handling statement, in the block of a lock statement, or in an unsafe context.

The thing is, if you call this code again and again, the await keyword would take the code back to from where it was called, and then you would come back to the same code execution, this threading of lock, unlock would cause a trouble in your code, maybe a deadlock, and basically you won't be able to get what you wanted to get.

Secondly, what Jon suggested on that answer is something like this:

C#

// Now it's clear where the locks will be acquired and released
lock (foo)
{
}
var result = await something;
lock (foo)
{
}

You would then execute the code that would alter the value of "foo", and then you will continue again.

Read Eric Lippert and Jon Skeet's answers to this thread, c# - Why can't I use the 'await' operator within the body of a lock statement? - Stack Overflow[^]

Posted 21-Jan-16 3:34am

Afzaal Ahmad Zeeshan

Comments

Henrik R L 21-Jan-16 9:45am

Hi Afzall

In your suggestion with a lock, await and then lock I think that thread1 could be just about to execute "await something" and then thread2 are allowed to go into the first lock and change a variable myVariable that we could asume would be used in the call "await something(myVariable)". Then thread1 will make the call "await something(myVariable)" with myVariable having a different value (changed by thread2). So I think there still is a problem?

Afzaal Ahmad Zeeshan 21-Jan-16 9:48am

Not mine, that was what was included in the answer that I referenced. The thing is that C# does not allow using await in lock environment.

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Richard Deeming · Accepted Answer · 2016-01-21T04:51:00

Assuming you want the return values to be 1 and 2, use the Interlocked.Increment Method[^] to increment the field, and store the result in a local variable to return at the end of the method:

C#

public class MyClass
{
    private int count = 0;
    
    public async Task<int> GetCount()
    {
        int result = Interlocked.Increment(ref count);
        
        await Task.Delay(1); 
 
        return result;
    }
}

If you want to limit the number of async tasks which can access a protected resource at the same time, then you need something like Stephen Toub's AsyncSemaphore[^] class:

C#

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public sealed class AsyncSemaphore
{
    private readonly Queue<TaskCompletionSource<IDisposable>> _waiters = new Queue<TaskCompletionSource<IDisposable>>();
    private readonly WaitCallback _releaseCoreCallback;
    private readonly Task<IDisposable> _releaserTask;
    private readonly Releaser _releaser;
    private readonly int _maxCount;
    private int _currentCount;

    public AsyncSemaphore(int initialCount)
    {
        if (initialCount < 0) throw new ArgumentOutOfRangeException("initialCount");

        _maxCount = _currentCount = initialCount;

        _releaser = new Releaser(this);
        _releaserTask = Task.FromResult((IDisposable)_releaser);
        _releaseCoreCallback = ReleaseCore;
    }

    public Task<IDisposable> WaitAsync()
    {
        lock (_waiters)
        {
            if (_currentCount > 0)
            {
                _currentCount--;
                return _releaserTask;
            }

            var waiter = new TaskCompletionSource<IDisposable>();
            _waiters.Enqueue(waiter);
            return waiter.Task;
        }
    }

    private void Release()
    {
        TaskCompletionSource<IDisposable> toRelease = null;
        lock (_waiters)
        {
            if (_waiters.Count > 0)
            {
                toRelease = _waiters.Dequeue();
            }
            else if (_currentCount < _maxCount)
            {
                _currentCount++;
            }
            else
            {
                throw new SemaphoreFullException();
            }
        }
        if (null != toRelease)
        {
            ThreadPool.QueueUserWorkItem(_releaseCoreCallback, toRelease);
        }
    }

    private void ReleaseCore([NotNull] object state)
    {
        ((TaskCompletionSource<IDisposable>)state).SetResult(_releaser);
    }

    private sealed class Releaser : IDisposable
    {
        private readonly AsyncSemaphore _throttle;

        public Releaser(AsyncSemaphore throttle)
        {
            _throttle = throttle;
        }

        public void Dispose()
        {
            _throttle.Release();
        }
    }
}

Usage would look something like this:

C#

public class MyClass
{
    // Only one task can access the file at a time:
    private static readonly AsyncSemaphore FileSemaphore = new AsyncSemaphore(1);
    
    public async Task DoSomething()
    {
        ...
        
        using (await FileSemaphore.WaitAsync())
        {
            // Access the file within this block...
        }
        
        ...
    }
}

Stephen wrote a whole series of blog posts on these async primitives: