Non-blocking, expected, exclusive accessors

I have a thread safe class that uses a specific resource that needs to be accessed exclusively. In my assessment, it doesn't make sense for the callers of various methods to block on Monitor.Enter

or wait SemaphoreSlim

to access this resource.

For example, I have some "expensive" asynchronous initialization. Since it doesn't make sense to initialize multiple times, whether from multiple threads or one, multiple calls should return immediately (or even throw an exception). Instead, you create init and then spread the instance across multiple threads.

UPDATE 1:

MyClass

uses two NamedPipes

in either direction. The method is InitBeforeDistribute

not an initialization, but a proper connection setup in both directions. It doesn't make sense to make available pipe for streams N

before you set up the connection. Once it is configured, multiple threads can send messages, but only one can actually read / write to the stream. I apologize for confusing this with bad example titles.

UPDATE 2:

If InitBeforeDistribute

implemented SemaphoreSlim(1, 1)

with the correct wait logic (instead of blocking the operation throwing an exception), is the Add / Do Square OK method practical? It doesn't throw a redundant exception (like in InitBeforeDistribute

) but doesn't block?

Below is an example good:

class MyClass
{
    private int m_isIniting = 0; // exclusive access "lock"
    private volatile bool vm_isInited = false; // vol. because other methods will read it

    public async Task InitBeforeDistribute()
    {
        if (Interlocked.Exchange(ref this.m_isIniting, -1) != 0)
            throw new InvalidOperationException(
                "Cannot init concurrently! Did you distribute before init was finished?");

        try
        {
            if (this.vm_isInited)
                return;

            await Task.Delay(5000)      // init asynchronously
                .ConfigureAwait(false);

            this.vm_isInited = true;
        }
        finally
        {
            Interlocked.Exchange(ref this.m_isConnecting, 0);
        }
    }
}

      

        
        
        
      

    

Some moments:

• If there is a case where the lock / pending access to the lock makes perfect sense, then this example doesn't make sense (makes sense, that is).
• Since I need to wait in a method, I have to use something like SemaphoreSlim if I am using the "correct" locking. Based on the Semaphore example above, I don't have to worry about when I'm done with this. (I've always disliked the idea of ​​recycling an item being used by multiple threads. This is minor positive, of course.)
• If the method is called frequently, there may be some performance benefit that must of course be measured.

The above example doesn't make sense in ref. to (3.), so here's another example:

class MyClass
{
    private volatile bool vm_isInited = false; // see above example
    private int m_isWorking = 0; // exclusive access "lock"
    private readonly ConcurrentQueue<Tuple<int, TaskCompletionSource<int>> m_squareWork =
        new ConcurrentQueue<Tuple<int, TaskCompletionSource<int>>();

    public Task<int> AddSquare(int number)
    {
        if (!this.vm_isInited) // see above example
            throw new InvalidOperationException(
                "You forgot to init! Did you already distribute?");

        var work = new Tuple<int, TaskCompletionSource<int>(number, new TaskCompletionSource<int>()
        this.m_squareWork.Enqueue(work);

        Task do = DoSquare();

        return work.Item2.Task;
    }

    private async Task DoSquare()
    {
        if (Interlocked.Exchange(ref this.m_isWorking, -1) != 0)
            return; // let someone else do the work for you

        do
        {
            try
            {
                Tuple<int, TaskCompletionSource<int> work;

                while (this.m_squareWork.TryDequeue(out work))
                {
                    await Task.Delay(5000)      // Limiting resource that can only be
                        .ConfigureAwait(false); // used by one thread at a time.

                    work.Item2.TrySetResult(work.Item1 * work.Item1);
                }
            }
            finally
            {
                Interlocked.Exchange(ref this.m_isWorking, 0);
            }
        } while (this.m_squareWork.Count != 0 &&
            Interlocked.Exchange(ref this.m_isWorking, -1) == 0)
    }
}

      

        
        
        
      

    

Are there some of the negative aspects of this "loose" example that I should look out for?

Most questions related to "lock-free" code on SO tend to advise against it, claiming it is for "experts". Rarely (I could be wrong on this), I see suggestions for books / blogs, etc. that one can delve into if anyone is so inclined. If there are any resources I should look into, please share. Any suggestions would be much appreciated!