Mit csinál a szinkronizáció a több szálas környezetben?

A több szálas programozás kontextusában a szinkronizáció megakadályozza a versenyhelyzeteket (race condition) és biztosítja a közös erőforrások (változók, fájlok, hálózati kapcsolatok) konzisztens hozzáférését különböző szálakról.

A fő szinkronizációs mechanizmusok:

• Mutex (kölcsönös kizárás): Csak egy szál lehet a mutex tulajdonosa és hozzáférhet a védett erőforráshoz.
• Semaphore (szemafor): Korlátozza, hogy hány szál férhet hozzá egy erőforráshoz egyidejűleg. Számlálóval működik.
• Lock (zár): Általános fogalom, gyakran mutex vagy más, teljes hozzáférést blokkoló mechanizmusokra utal.
• Dispatch Queue (küldési sor): A Grand Central Dispatch (GCD) esetében a sorok lehetnek szekvenciálisak (sorozatosak) vagy párhuzamosak, és a feladatok sorrendjének és számának kezelésével biztosítják a szinkronizációt. A szekvenciális sorok garantálják a feladatok egymás utáni végrehajtását, ami inherent módon biztosítja az adatok szinkronizálását, amelyek csak a sor feladataiból érhetők el.

Működési elv: Egy szál, amely hozzáférést kíván egy közös erőforráshoz, először megpróbálja megszerezni a zárolást (lock). Ha az erőforrás szabad, a szál megkapja a zárolást és dolgozik az erőforrással. A munka befejezése után felszabadítja a zárolást (release lock). Ha az erőforrás foglalt, más szálak blokkolódnak (várakoznak), amíg az erőforrás nem szabadul fel.

Példa mutex használatára kritikus szekció védelmében:

// Objective-C példában @synchronized használatával
- (void)updateSharedResource {
    @synchronized (self) { // zárolás a self objektumon
        // Itt hajtódik végre a kritikus szekció
        // A sharedResource hozzáférése biztonságos
        self.sharedResource++;
    } // A zárolás automatikusan felszabadul a blokk elhagyásakor
}

// Swift példában NSLock használatával
let lock = NSLock()
var sharedCounter = 0

func incrementCounter() {
    lock.lock() // A zárolás megszerzése
    // Kritikus szekció
    sharedCounter += 1
    lock.unlock() // A zárolás feloldása
}

A szinkronizáció segít elkerülni az alábbi problémákat:

• Adatkárosodás.
• Deadlock (kölcsönös zárolás) szálak között.
• Livelock (aktív zárolások) szálak között.

A megfelelő szinkronizációs mechanizmus kiválasztása a feladat természetétől és az erőforrás típusától függ.