免锁定、不可用、独占的访问方法

我有一个线程安全类，它使用需要以独占方式访问的特定资源。在我的评估中，让各种方法的调用方阻塞Monitor.Enter或等待SemaphoreSlim以访问此资源是没有意义的。

例如，我有一些"昂贵"的异步初始化。由于多次初始化是没有意义的，无论是来自多个线程还是单个线程，多个调用都应该立即返回(甚至抛出异常(。相反，应该创建、init和，然后将实例分发到多个线程。

更新1:

CCD_ 3在任一方向上使用两个CCD_。InitBeforeDistribute方法并不是真正的初始化，而是在两个方向上正确地建立连接。在设置连接之前，使管道可用于N线程是没有意义的。一旦设置好，多个线程就可以发布工作，但实际上只有一个线程可以读取/写入流。我很抱歉用不恰当的例子命名混淆了这一点。

更新2:

如果InitBeforeDistribute实现了具有适当等待逻辑的SemaphoreSlim(1, 1)(而不是抛出异常的互锁操作(，那么Add/Do-Square方法可以实践吗？它没有抛出冗余异常(例如在InitBeforeDistribute中(，同时是无锁的？

以下将是

好坏的示例：

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

一些要点：

1. 如果存在阻止/等待访问锁的情况完美的意义，那么这个例子就没有意义了
2. 由于我需要在方法中等待，我必须使用类似SemaphoreSlim如果我在哪里使用"正确"的锁。忘记上面例子的信号量让我不用担心(我总是不喜欢处理多个线程使用的项目的想法。这是一个小调肯定是肯定的。(
3. 如果经常调用该方法，则可能会有一些性能好处，当然应该衡量

上面的例子在参考文献(3(中没有意义，所以这里是另一个例子：

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

这个"无锁"的例子有没有一些具体的负面方面需要我注意？

大多数与SO上的"免锁"代码有关的问题通常都建议不要这样做，并表示这是为"专家"准备的。我很少(在这一点上我可能错了(看到人们可以深入研究的书籍/博客等的建议，如果人们有这样的倾向的话。如果有任何这样的资源我应该研究，请分享。如有任何建议，我们将不胜感激！