Hogyan kezeljük a szálakkal (threads) és feladatokkal (tasks) való munkát, ha többük ugyanarra az állapotra hivatkozik?

A több szálas környezetben a közös állapot biztonságos eléréséhez szinkronizációs mechanizmusokat alkalmaznak.

Fő megközelítések:

• Zárak: A lock a legelterjedtebb mechanizmus. Egy kódrészlet vagy objektum kizárólagos hozzáférését biztosítja egy szál számára egyszerre. Mutex (kölcsönös kizárás) szintén használatos, de gyakran folyamatok közötti kommunikációban.
• Szemantika: Korlátozza, hogy hány szál férhet hozzá egy erőforráshoz egyidejűleg.
• Monitor: A lock-nál erősebb változat, amely lehetővé teszi a szálak számára, hogy várakozzanak más szálak értesítésére.
• ReadWriteLock: Több szál olvashatja az adatokat egyidejűleg, de csak egy írhat.
• Atomi műveletek: Egyszerű műveletekhez (inkrementálás, dekrementálás, összehasonlítás-csere) a Interlocked osztály statikus metódusait lehet használni.

A feladatok (Tasks) kezelésénél, különösen az async/await használatakor, fontos megjegyezni, hogy a feladatok nem kötődnek egy adott szálhoz. A szinkronizációs kontextusok (SynchronizationContext) segítenek visszatérni a kívánt kontextusba (pl. UI szál) az aszinkron művelet befejezése után.

A lock példája:

// Záróobjektum
private readonly object _lockObject = new object();
private int _sharedCounter = 0;

public void IncrementCounter()
{
    // A közös számláló zárolása
    lock (_lockObject)
    {
        _sharedCounter++;
    }
}

Az Interlocked példája:

private int _sharedAtomicCounter = 0;

public void IncrementAtomicCounter()
{
    // Atomikus növelés
    Interlocked.Increment(ref _sharedCounter);
}