Hoe wordt gewerkt met threads en taken in C# wanneer…

Bij het werken met een gedeelde toestand door meerdere threads in C# kunnen synchronisatieproblemen en racecondities optreden. Om threadveiligheid te garanderen, worden de volgende mechanismen gebruikt:

Locking:

De operator lock wordt gebruikt om een kritieke sectie te creëren die garandeert dat slechts één thread tegelijk toegang heeft tot de beschermde bron.
Vereist een lock-object (meestal private readonly object) dat wordt gebruikt voor synchronisatie.

// Voorbeeld van gebruik van lock
private readonly object _lockObject = new object();
private int _sharedCounter = 0;

public void IncrementCounter()
{
    lock (_lockObject)
    {
        _sharedCounter++; // Kritieke sectie
    }
}

Atomische operaties:

De klasse System.Threading.Interlocked biedt atomische operaties (bijvoorbeeld Increment, Decrement, Add, Exchange) die thread-safe zijn en geen expliciete lock vereisen.

// Voorbeeld van gebruik van Interlocked
private volatile int _sharedValue = 0; // volatile voor zichtbaarheid van wijzigingen

public void UpdateValue(int newValue)
{
    Interlocked.Exchange(ref _sharedValue, newValue); // Atomische toewijzing
}

public void IncrementValue()
{
    Interlocked.Increment(ref _sharedValue); // Atomische verhoging
}

Hoewel volatile de zichtbaarheid van wijzigingen tussen threads garandeert, verzekert het niet de atomariteit van meerstapsoperaties. Voor atomare operaties moet Interlocked worden gebruikt.

Synchronisatieklassen uit System.Threading en System.Threading.Tasks:
- Monitor: een lager niveau mechanisme dan lock.
- Mutex: stelt je in staat om toegang tot een bron tussen meerdere processen te synchroniseren.
- SemaphoreSlim: beperkt het aantal threads dat gelijktijdig toegang kan krijgen tot een bron.
- ReaderWriterLockSlim: stelt meerdere threads in staat om de bron gelijktijdig te lezen, maar slechts één te schrijven.
Thread-safe collecties:
- De namespace System.Collections.Concurrent bevat collecties (ConcurrentBag<T>, ConcurrentDictionary<TKey, TValue>, ConcurrentQueue<T>, ConcurrentStack<T>) die specifiek zijn ontworpen voor gelijktijdige toegang. Het gebruik van deze collecties elimineert de noodzaak voor handmatige synchronisatie bij basisbewerkingen.
```
// Voorbeeld van gebruik van ConcurrentDictionary
private ConcurrentDictionary<string, int> _sharedData = new ConcurrentDictionary<string, int>();

public void AddOrUpdateData(string key, int value)
{
    _sharedData.AddOrUpdate(key, value, (k, oldValue) => oldValue + value);
}
```
Onveranderlijke objecten:
- Het maken van onveranderlijke (immutable) objecten betekent dat, eenmaal gemaakt, hun toestand niet kan worden gewijzigd. Als de gedeelde toestand wordt weergegeven door een onveranderlijk object, kunnen meerdere threads het veilig lezen zonder synchronisatie. Het bijwerken van de toestand komt neer op het maken van een nieuw exemplaar van het object.

Bij het werken met taken (Task) in TPL (Task Parallel Library) moet ook rekening worden gehouden met synchronisatie bij toegang tot de gedeelde toestand. TPL vereenvoudigt het maken en beheren van parallelle operaties, maar ontslaat niet van de verantwoordelijkheid om threadveiligheid te garanderen bij het werken met gedeelde gegevens.

De keuze van het juiste synchronisatie-mechanisme hangt af van de specifieke taak en de kenmerken van de toegang tot de gedeelde toestand.

Hoe wordt gewerkt met threads en taken in C# wanneer meerdere threads toegang hebben tot een gedeelde staat?