`Sincronizarea Firelor cu Noul Tip System.Threading.Lock în C# 13 și .NET 9` în C# (.NET)

Memorie și Performanță Avansată C# 13 / .NET 9

Ghid complet pentru noul tip System.Threading.Lock introdus în C# 13 și .NET 9: modernizarea instrucțiunii lock, eliminarea alocărilor SyncBlock și performanță superioară față de vechiul pattern cu object.

Sintaxă C#

private readonly Lock _gate = new(); lock (_gate) { ... }

Istoric, sincronizarea secțiunilor critice în C# folosea instrucțiunea lock aplicată pe o instanță oarecare de obiect:

private readonly object _syncRoot = new object();
lock (_syncRoot) { /* secțiune critică */ }

Deși convenabil, acest mecanism depindea de o structură internă complexă a runtime-ului CLR numită SyncBlock, alocată dinamic în antetul fiecărui obiect la primul lock. Acest lucru introducea overhead de memorie, penalizări de performanță și riscul ca un dezvoltator să blocheze accidental o structură sau un șir partajat din greșeală.

În C# 13 și .NET 9, Microsoft introduce tipul specializat System.Threading.Lock, iar compilatorul recunoaște acest tip și optimizează automat instrucțiunea lock.

Utilizarea Noului Tip System.Threading.Lock

using System.Threading;

public class ContorThreadSafe
{
    // Folosim noul tip dedicat de blocare din .NET 9:
    private readonly Lock _lacat = new Lock();
    private int _valoare = 0;

    public void Incrementeaza()
    {
        // Compilatorul C# 13 transformă automat acest apel în apelul optimizat _lacat.EnterScope():
        lock (_lacat)
        {
            _valoare++;
        }
    }

    public int Citeste()
    {
        lock (_lacat)
        {
            return _valoare;
        }
    }
}

Avantaje Tehnice Măsurabile

Performanță Superioară: System.Threading.Lock este optimizat la nivel de procesor și este cu 15-25% mai rapid în scenarii de blocare concurentă intensă decât vechiul monitor CLR.
API Modern Scope-based: Permite utilizarea directă cu using (_lacat.EnterScope()) { ... }, structura returnată fiind un ref struct cu zero alocări de memorie pe Heap.