Коллекция вопросов ❓ на собеседовании в C# 🍧

Обзор вопросов по языка програмиированию C# и технологии NET

---

Project maintained by Dvurechensky-Docs Hosted on GitHub Pages — Theme by mattgraham

⏳ Какие бывают примитивы синхронизации в .NET?

✨ Оглавление

• ✨ Оглавление
  • 1️⃣ Основная идея
  • 2️⃣ lock (Monitor)
  • 3️⃣ Mutex (System.Threading.Mutex)
  • 4️⃣ Semaphore и SemaphoreSlim
    • Semaphore
    • SemaphoreSlim
  • 5️⃣ AutoResetEvent и ManualResetEvent
  • 6️⃣ Monitor.Wait() / Monitor.Pulse() / PulseAll()
  • 7️⃣ ReaderWriterLockSlim
  • 8️⃣ Interlocked
  • 9️⃣ Каверзные моменты и подводные камни
  • 🔟 Таблица примитивов

⬆ Вернуться к главной

---

1️⃣ Основная идея

• Примитивы синхронизации нужны для:

  • Предотвращения гонок данных (race conditions).
  • Согласования доступа к общим ресурсам.
  • Организации взаимодействия между потоками (thread coordination).

• В .NET есть несколько уровней примитивов: от простых до более сложных, включая асинхронные варианты.

---

2️⃣ lock (Monitor)

• Самый базовый способ синхронизации.
• Синтаксис:

private readonly object _lock = new object();

lock(_lock)
{
    // критическая секция
}

• Под капотом использует Monitor.Enter / Monitor.Exit.

• Особенности:

  • Позволяет только одному потоку войти в критическую секцию.
  • Блокировка рекурсивная: один поток может войти несколько раз.
  • В сочетании с Monitor.Wait() и Monitor.Pulse() можно делать условные ожидания.

---

3️⃣ Mutex (System.Threading.Mutex)

• Межпроцессный примитив: может использоваться для синхронизации потоков между процессами.
• Пример:

Mutex mutex = new Mutex();
mutex.WaitOne(); // захват
try
{
    // критическая секция
}
finally
{
    mutex.ReleaseMutex();
}

• Особенности:

  • Более дорогой, чем lock.
  • Используется редко для потоков в одном процессе; чаще для межпроцессной синхронизации.
  • Может быть named для нескольких процессов.

---

4️⃣ Semaphore и SemaphoreSlim

Semaphore

• Ограничивает количество потоков, одновременно заходящих в секцию.
• Пример:

Semaphore sem = new Semaphore(2, 5); // максимум 2 потока одновременно
sem.WaitOne();
// критическая секция
sem.Release();

SemaphoreSlim

• Более лёгкий, только для одного процесса.

• Поддерживает асинхронные методы:

  • WaitAsync()

• Отличие от обычного Semaphore:

  • Быстрее, меньше накладных расходов.
  • Не межпроцессный.

---

5️⃣ AutoResetEvent и ManualResetEvent

• События (events) для сигнализации между потоками.

• AutoResetEvent

  • Сбрасывается автоматически после одного потока.
  • Используется для одиночного уведомления.

• ManualResetEvent

  • Сохраняет сигнал до явного сброса (Reset()).
  • Можно пропускать несколько потоков после сигнала.
• Пример:

AutoResetEvent are = new AutoResetEvent(false);

Thread t = new Thread(() =>
{
    Console.WriteLine("Waiting...");
    are.WaitOne(); // ждёт сигнала
    Console.WriteLine("Signaled!");
});

t.Start();
Thread.Sleep(1000);
are.Set(); // отправка сигнала

---

6️⃣ Monitor.Wait() / Monitor.Pulse() / PulseAll()

• Используются в сочетании с lock/Monitor.
• Wait() — поток ждёт сигнала, отпуская lock.
• Pulse() — сигнал одному ожидающему потоку.
• PulseAll() — сигнал всем ожидающим потокам.
• Пример:

lock(_lock)
{
    while(!condition) Monitor.Wait(_lock);
    // обработка
    Monitor.Pulse(_lock);
}

• Часто используется для producer/consumer pattern.

---

7️⃣ ReaderWriterLockSlim

• Позволяет:

  • Много потоков для чтения.
  • Один поток для записи.

• Пример:

ReaderWriterLockSlim rwLock = new ReaderWriterLockSlim();

// Чтение
rwLock.EnterReadLock();
try { /* чтение */ } finally { rwLock.ExitReadLock(); }

// Запись
rwLock.EnterWriteLock();
try { /* запись */ } finally { rwLock.ExitWriteLock(); }

• Эффективно при частых чтениях и редких записях.

---

8️⃣ Interlocked

• Простые атомарные операции с числами.

• Методы:

  • Interlocked.Increment(ref x)
  • Interlocked.Decrement(ref x)
  • Interlocked.Add(ref x, value)
  • Interlocked.Exchange(ref x, newValue)
  • Interlocked.CompareExchange(ref x, newValue, comparand)
• Используется для микросинхронизации без блокировок.
• Быстро, но ограничено на простые типы (int, long, IntPtr).

---

9️⃣ Каверзные моменты и подводные камни

1. lock vs Monitor

   • lock — синтаксический сахар для Monitor.Enter/Exit.
   • Нужно никогда не блокировать на публичных объектах (возможны deadlock/внешние вмешательства).

2. Mutex vs Semaphore

   • Mutex → дорого, межпроцессный.
   • SemaphoreSlim → лёгкий, для одного процесса.

3. Deadlock

   • Два потока ждут друг друга → взаимная блокировка.
   • Часто при nested lock / комбинировании нескольких примитивов.

4. Async / await

   • Для асинхронных методов:

     • SemaphoreSlim.WaitAsync()
     • AsyncLock (от сторонних библиотек)

   • lock не совместим с await внутри, нужен AsyncLock.

5. Производительность

   • Interlocked быстрее всех.
   • lock медленнее, но проще и безопаснее.
   • Mutex самый дорогой.

---

🔟 Таблица примитивов

Примитив	Scope	Особенности	Поддержка async
lock / Monitor	Один процесс	Рекурсивный, блокирует поток	Нет
Mutex	Межпроцессный	Можно именовать, дорогой	Нет
Semaphore	Один/Межпроцессный	Ограничение N потоков	Нет
SemaphoreSlim	Один процесс	Лёгкий, поддержка async	Да
AutoResetEvent	Один процесс	Сигнал одному потоку	Нет
ManualResetEvent	Один процесс	Сигнал всем потокам	Нет
ReaderWriterLockSlim	Один процесс	Много читателей, один писатель	Нет
Interlocked	Один процесс	Атомарные операции с числами	Да (частично)

---

⬆ Вернуться к главной

✨Dvurechensky✨