Kuidas toimub töö lõngade (threads) ja ülesannete (tasks)ga, kui mitu neist pöörduvad ühise oleku poole?

Kaitsemeetodid jagatud oleku turvaliseks kasutamiseks mitmetuumalises keskkonnas hõlmavad sünkroneerimismehhanisme.

Peamised lähenemisviisid:

• Blokeerimine: lock on kõige levinum mehhanism. Tagab monopoolsed juurdepääs koodiplokile või objektile ühel protsessil korraga. Mutex (vastastikune välistus) kasutatakse samuti, kuid sageli vaheprotsessilises suhtluses.
• Semantika: piirab protsesside arvu, kes saavad samaaegselt ressursile ligi.
• Monitor: on võimsam lock analoog, mis võimaldab protsessidel oodata teistelt protsessidelt teateid.
• ReadWriteLock: võimaldab paljudel protsessidel andmeid samaaegselt lugeda, kuid kirjutada saab ainult üks protsess korraga.
• Atomaarsed operatsioonid: lihtsate operatsioonide (inkrement, dekrement, võrdlus-vahetus) jaoks saab kasutada Interlocked klassi staatilisi meetodeid.

Töödeldes ülesandeid (Tasks), eriti async/await kasutades, on oluline meeles pidada, et ülesanded ei ole seotud konkreetse protsessiga. Sünkroniseerimiskontekstid (SynchronizationContext) aitavad naasta vajaliku konteksti (näiteks UI-protsess) pärast asünkroonse operatsiooni lõpetamist.

lock näide:

// Lukustusobjekt
private readonly object _lockObject = new object();
private int _sharedCounter = 0;

public void IncrementCounter()
{
    // Juurdepääsu lukustamine ühisele loendurile
    lock (_lockObject)
    {
        _sharedCounter++;
    }
}

Interlocked näide:

private int _sharedAtomicCounter = 0;

public void IncrementAtomicCounter()
{
    // Atomaarselt suurendamine
    Interlocked.Increment(ref _sharedAtomicCounter);
}