What methods have you used to ensure thread safety when executing tasks concurrently?

To ensure safe thread operation when executing tasks concurrently in C#, various synchronization and access control mechanisms are used:

• lock — locks a critical section of code so that only one thread can execute it at a time.
• Mutex — inter-process lock, useful when working with resources accessible from different processes.
• Semaphore and SemaphoreSlim — limit the number of threads that can access a resource simultaneously.
• Monitor — a more flexible locking mechanism that allows waiting and signaling about events.
• Concurrent collections (e.g., ConcurrentDictionary, ConcurrentQueue) — provide thread-safe access to collections.
• Interlocked — atomic operations on variables to prevent race conditions.

Example of using lock:

private readonly object _lockObj = new object();
private int _counter = 0;

public void Increment()
{
    lock(_lockObj)
    {
        _counter++;
    }
}

This approach prevents simultaneous modification of _counter from different threads, avoiding race conditions and ensuring data correctness.