Как происходит работа с потоками и задачами в C#, если несколько потоков обращаются к общему состоянию?

При работе с общим состоянием несколькими потоками в C# возникают проблемы синхронизации и возможные состояния гонки. Для обеспечения потокобезопасности используются следующие механизмы:

1. Блокировка (Locking):

   • Используется оператор lock для создания критической секции, гарантирующей, что только один поток может получить доступ к защищаемому ресурсу за раз.
   • Требует наличия объекта-заглушки (обычно private readonly object), который используется для синхронизации.

   // Пример использования lock
   private readonly object _lockObject = new object();
   private int _sharedCounter = 0;
   
   public void IncrementCounter()
   {
       lock (_lockObject)
       {
           _sharedCounter++; // Критическая секция
       }
   }
   

2. Атомарные операции:

   • Класс System.Threading.Interlocked предоставляет атомарные операции (например, Increment, Decrement, Add, Exchange), которые являются потокобезопасными и не требуют явной блокировки для выполнения одной операции.

   // Пример использования Interlocked
   private volatile int _sharedValue = 0; // volatile для видимости изменений
   
   public void UpdateValue(int newValue)
   {
       Interlocked.Exchange(ref _sharedValue, newValue); // Атомарное присваивание
   }
   
   public void IncrementValue()
   {
        Interlocked.Increment(ref _sharedValue); // Атомарное увеличение
   }
   

   • Хотя volatile обеспечивает видимость изменений между потоками, он не гарантирует атомарность многошаговых операций. Для атомарных операций следует использовать Interlocked.

3. Классы синхронизации из System.Threading и System.Threading.Tasks:

   • Monitor: Более низкоуровневый механизм блокировки по сравнению с lock.
   • Mutex: Позволяет синхронизировать доступ к ресурсу между несколькими процессами.
   • SemaphoreSlim: Ограничивает количество потоков, которые одновременно могут получить доступ к ресурсу.
   • ReaderWriterLockSlim: Позволяет множеству потоков читать ресурс одновременно, но только одному потоку писать.

4. Потокобезопасные коллекции:

   • Пространство имен System.Collections.Concurrent содержит коллекции (ConcurrentBag<T>, ConcurrentDictionary<TKey, TValue>, ConcurrentQueue<T>, ConcurrentStack<T>), разработанные специально для многопоточного доступа. Использование этих коллекций устраняет необходимость в ручной синхронизации при базовых операциях с коллекцией.

   // Пример использования 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);
   }
   

5. Immutable-объекты:

   • Создание неизменяемых объектов (immutable) означает, что после создания их состояние нельзя изменить. Если общее состояние представлено неизменяемым объектом, множественные потоки могут безопасно читать его без необходимости синхронизации. Обновление состояния сводится к созданию нового экземпляра объекта.

При работе с задачами (Task) в TPL (Task Parallel Library) также необходимо учитывать синхронизацию при доступе к общему состоянию. TPL упрощает создание и управление параллельными операциями, но не снимает ответственность за обеспечение потокобезопасности при работе с общими данными.

Выбор подходящего механизма синхронизации зависит от конкретной задачи и характеристик доступа к общему состоянию.