Warum gibt ReaderWriterLock den Besitz nicht automatisch frei/beendet, wenn der Eigentümerthread beendet wird?

Question

Dies ist eine theoretische Frage; Ich habe kein tatsächliches Problem zu lösen, ich möchte nur das Verständnis dafür bekommen, warum dies funktioniert.

Ich habe herausgefunden, dass, wenn ein Thread versäumt, einen ReaderWriterLock zu verlassen, andere Threads nach Beendigung des ursprünglichen Threads den Lock nicht erhalten können. Gibt es einen guten Grund dafür, dass ReaderWriterLock den Lock nicht an wartende Threads vergibt, sobald der Thread, der den Lock besitzt, endet?

Hier ist ein Testfall, der das Problem demonstriert.

    static void Main(string[] args)
    {
        ReaderWriterLockSlim readerWriterLock = new ReaderWriterLockSlim();

        Thread t1 = new Thread((a) =>
        {
            readerWriterLock.EnterReadLock();

            // dieser Thread lässt es aus, den Lock zu verlassen....
        });

        Thread t2 = new Thread((a) =>
        {
            readerWriterLock.EnterWriteLock();
        });

        t1.Start();
        t2.Start();

        // warte darauf, dass alle Threads beendet sind
        t1.Join();
        t2.Join();
    }

Answer 1

Die simple Antwort: Es gibt keinen einfachen Weg für den Schreib-Thread zu wissen, dass die Lese-Threads beendet wurden, ohne auch die Sperrvorgänge teuer zu machen.

Sperren werden normalerweise als Werte im Speicher implementiert, sodass das Erlangen und Freigeben des Schlosses eine Änderung dieser Werte umfasst. Wenn ein Thread den Wert aufnimmt, um das Schloss zu erwerben und dann abstürzt, kann ein anderes Schloss nur erworben werden, wenn Sie einen Hintergrundthread haben, der nach abgestürzten Threads sucht, deren Liste kürzlich erworbener Schlösser überprüft und diese bereinigt.

Zusätzlich dazu, dass dies teuer ist und eine Menge Verrohrung erfordert, ist es potenziell unsicher, weil Sie nicht genau wissen, wie weit der Thread gekommen ist, bevor er abgestürzt ist.

Answer 2

Es wäre wahrscheinlich nicht allzu schwer für ein Schloss, die Identität des Threads zu speichern, der es ausschließlich hält, oder eine Liste von Threads, die es nicht exklusiv halten. Der Sperrcode könnte dann periodisch überprüfen, während er blockiert ist, ob die Threads, die ihn blockieren, noch am Leben sind. Das größte Problem dabei ist, dass es keinen standardisierten Weg gibt, für Threads anzuzeigen, zu welchen Zeitpunkten die von dem Schloss geschützten Entitäten sich in einem legitimen Zustand oder einem ungültigen Zustand befinden. Wenn ein Thread, der ein Schloss hält, stirbt, während die geschützten Entitäten sich in einem ungültigen Zustand befinden, sollte der Zugriff auf diese Entitäten verboten bleiben, es sei denn, dass ein Code, der weiß, wie mit der Beschädigung umzugehen ist, dies getan hat.