Wie implementiert man die asynchrone Sperrung mit SemaphoreSlim richtig, um zeitweilige Dateizugriffsfehler zu verhindern?

Behebung zeitweiliger Dateizugriffsfehler mit asynchroner Sperrung

In der ImageProcessor-Bibliothek sind kürzlich bei Cache-Aktualisierungen zeitweise Dateizugriffsfehler aufgetreten, die auf fehlerhafte asynchrone Sperren zurückzuführen sind. Dieser Artikel analysiert die ursprüngliche fehlerhafte Implementierung und bietet eine robuste Lösung.

Der ursprüngliche Ansatz verwendete gehashte URLs als Schlüssel für asynchrone Sperren und speicherte SemaphoreSlim Instanzen in einem ConcurrentDictionary, um eine Einzelschlüsselsperre sicherzustellen. Der kritische Fehler bestand darin, dass SemaphoreSlim synchron aus dem Wörterbuch entfernt wurde, bevor das Semaphor freigegeben wurde. Diese Race-Bedingung führte zu Dateizugriffskonflikten.

Der folgende Codeausschnitt veranschaulicht die problematische Schlüssel-/SemaphoreSlimReferenzierung:

<code class="language-csharp">private static readonly Dictionary<object, RefCounted<SemaphoreSlim>> SemaphoreSlims
                        = new Dictionary<object, RefCounted<SemaphoreSlim>>();

private SemaphoreSlim GetOrCreate(object key)
{
    RefCounted<SemaphoreSlim> item;
    lock (SemaphoreSlims)
    {
        if (SemaphoreSlims.TryGetValue(key, out item))
        {
            ++item.RefCount;
        }
        else
        {
            item = new RefCounted<SemaphoreSlim>(new SemaphoreSlim(1, 1));
            SemaphoreSlims[key] = item;
        }
    }
    return item.Value;
}</code>

Unten finden Sie die korrigierte AsyncDuplicateLock-Klasse, die das Parallelitätsproblem löst:

<code class="language-csharp">public sealed class AsyncDuplicateLock
{
    private sealed class RefCounted<T>
    {
        public RefCounted(T value)
        {
            RefCount = 1;
            Value = value;
        }

        public int RefCount { get; set; }
        public T Value { get; private set; }
    }

    private static readonly Dictionary<object, RefCounted<SemaphoreSlim>> SemaphoreSlims
                        = new Dictionary<object, RefCounted<SemaphoreSlim>>();

    private SemaphoreSlim GetOrCreate(object key)
    {
        RefCounted<SemaphoreSlim> item;
        lock (SemaphoreSlims)
        {
            if (SemaphoreSlims.TryGetValue(key, out item))
            {
                ++item.RefCount;
            }
            else
            {
                item = new RefCounted<SemaphoreSlim>(new SemaphoreSlim(1, 1));
                SemaphoreSlims[key] = item;
            }
        }
        return item.Value;
    }

    public IDisposable Lock(object key)
    {
        GetOrCreate(key).Wait();
        return new Releaser { Key = key };
    }

    public async Task<IDisposable> LockAsync(object key)
    {
        await GetOrCreate(key).WaitAsync().ConfigureAwait(false);
        return new Releaser { Key = key };
    }

    private sealed class Releaser : IDisposable
    {
        public object Key { get; set; }

        public void Dispose()
        {
            RefCounted<SemaphoreSlim> item;
            lock (SemaphoreSlims)
            {
                item = SemaphoreSlims[Key];
                --item.RefCount;
                if (item.RefCount == 0)
                    SemaphoreSlims.Remove(Key);
            }
            item.Value.Release();
        }
    }
}</code>

Diese überarbeitete Implementierung stellt sicher, dass das Semaphor bevor aus dem Wörterbuch entfernt wird, wodurch die Race-Bedingung beseitigt und die zeitweiligen Dateizugriffsfehler behoben werden.

Das obige ist der detaillierte Inhalt vonWie implementiert man die asynchrone Sperrung mit SemaphoreSlim richtig, um zeitweilige Dateizugriffsfehler zu verhindern?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!