Все программы, которые мы писали до этого момента, работали в одном потоке. Одна команда за другой, строго по порядку, сверху вниз. Как очередь в магазине с одной кассой: пока один покупатель не рассчитается — следующий ждёт.

И знаете что? Для большинства задач этого было достаточно. Калькулятор, RPG-движок, LINQ-запросы — всё работало отлично. Но рано или поздно вы столкнётесь с ситуацией, где одного потока мало. И вот тогда начнётся самое интересное. Давайте посмотрим, где однопоточность становится проблемой. Три реальных сценария.

Сценарий 1: программа «зависла». Вы написали приложение с интерфейсом. Пользователь нажимает кнопку «Загрузить данные». Загрузка идёт 10 секунд. Всё это время интерфейс не реагирует — кнопки не нажимаются, окно не двигается, Windows предлагает «завершить зависшую программу». Пользователь нервничает. А программа не зависла — она просто занята загрузкой и не может одновременно обрабатывать клики.

Сценарий 2: медленно, хотя процессор простаивает. Вам нужно обработать миллион записей — пересчитать цены, наложить фильтры, сгенерировать отчёт. Программа работает 30 секунд. Вы открываете диспетчер задач и видите: одно ядро загружено на 100%, а остальные семь — на нуле. У вас 8-ядерный процессор, а программа использует только одно ядро. Остальные семь стоят без дела, как работники, которых забыли позвать на смену.

Сценарий 3: ожидание впустую. Программа отправляет запрос на сервер и ждёт ответа. Пока ответ не пришёл — поток стоит. Не считает, не обрабатывает — просто ждёт. А вы могли бы за это время сделать ещё десять полезных вещей.

Все три проблемы объединяет одно: программа делает что-то одно в каждый момент времени. Многопоточность позволяет делать несколько вещей одновременно. На самом деле вы уже пользуетесь многопоточностью каждый день — просто не задумываетесь об этом. Ваш браузер прямо сейчас: одна вкладка воспроизводит видео, другая скачивает файл, в третьей вы читаете этот урок. Всё одновременно. Мессенджер получает сообщения, пока вы набираете текст. Антивирус сканирует файлы, не мешая вам работать. За всем этим стоят потоки.

Итак, зачем нам потоки? Если коротко — четыре причины:

Скорость. У вас миллион элементов, и каждый нужно обработать. Один поток сделает это за 30 секунд. Четыре потока — за 8. Операции независимы друг от друга — почему бы не раздать их четырём «работникам»? Это как четыре кассы вместо одной: очередь тает в четыре раза быстрее.

Отзывчивость. Пользователь не должен смотреть на замёрзшее окно. Тяжёлую работу — в фоновый поток, а основной поток продолжает обрабатывать интерфейс. Нажал кнопку «Сохранить» в Word — файл сохраняется в фоне, а вы продолжаете печатать. Вот так должно работать.

Использование оборудования. Ваш процессор имеет 8 ядер. Однопоточная программа использует одно из них. Остальные семь — простаивают. Это всё равно что арендовать восьмиполосное шоссе и ехать по одной полосе.

Фоновые задачи. Логирование, отправка метрик, проверка обновлений, автосохранение — всё это должно происходить незаметно, не прерывая основную работу.

Но есть и обратная сторона. Многопоточность — это мощный инструмент, но и опасный. Когда два потока одновременно лезут в одни и те же данные — начинаются проблемы, которые порой сложнее самой задачи: гонки данных, взаимные блокировки, непредсказуемое поведение. Программа может работать правильно 999 раз из 1000, а на тысячный — выдать мусор. И попробуй это отлови.

Именно поэтому существует целый блок уроков, а не один. Мы будем разбираться постепенно:

1. Потоки — как создавать, запускать, управлять.

2. Синхронизация — как защитить данные от одновременного доступа (lock, Mutex, Semaphore).

3. Проблемы — состояние гонки, deadlock, и как их избегать.

4. Пул потоков и Task — современный и удобный способ параллелизма.

5. async/await — асинхронное программирование без ручного управления потоками.

6. Финальный проект — всё вместе в одном работающем приложении.

К концу блока вы будете уверенно писать многопоточный код и понимать, что происходит «под капотом» любого серверного приложения.