В чем различия асинхронности и многопоточности?

В чём различия асинхронности и многопоточности?

Это часто путают, но это совершенно разные концепции. Обе используются для параллельной обработки, но по-разному.

Многопоточность (Multithreading)

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

public class MultiThreadExample
{
    public static void Main()
    {
        // Создаём 3 потока
        var thread1 = new Thread(() => DoWork("Thread-1"));
        var thread2 = new Thread(() => DoWork("Thread-2"));
        var thread3 = new Thread(() => DoWork("Thread-3"));
        
        thread1.Start();
        thread2.Start();
        thread3.Start();
        
        // Блокируем основной поток до завершения других
        thread1.Join();
        thread2.Join();
        thread3.Join();
        
        Console.WriteLine("Все потоки завершены");
    }
    
    private static void DoWork(string threadName)
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"{threadName}: работа {i}");
            Thread.Sleep(1000);
        }
    }
}

Характеристики:

• Реальный параллелизм на многоядерных системах
• Каждый поток занимает ресурсы (память, стек)
• Требуется синхронизация (lock, Monitor, Mutex)
• Сложнее в отладке (race conditions)
• Блокирует поток при ожидании I/O операций

Асинхронность (Asynchrony)

Асинхронность — это один поток, который может обрабатывать несколько операций, переключаясь между ними, пока ждёт результатов (I/O, сеть и т.д.).

public class AsyncExample
{
    public static async Task Main()
    {
        // Запускаем 3 операции с использованием одного потока
        var task1 = DoWorkAsync("Task-1");
        var task2 = DoWorkAsync("Task-2");
        var task3 = DoWorkAsync("Task-3");
        
        // Ждём завершения всех задач
        await Task.WhenAll(task1, task2, task3);
        
        Console.WriteLine("Все задачи завершены");
    }
    
    private static async Task DoWorkAsync(string taskName)
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine($"{taskName}: работа {i}");
            // Ждём 1 секунду БЕЗ блокировки потока
            await Task.Delay(1000);
        }
    }
}

Характеристики:

• Один поток обрабатывает несколько операций
• Очень эффективно для I/O-bound операций
• Минимальные ресурсы
• Не требует синхронизации
• Не блокирует поток при ожидании

Наглядное сравнение

Многопоточность (3 потока обедают одновременно):

Поток-1: едят -----
Поток-2: едят -----
Поток-3: едят -----

Общее время: 1 блюдо

Асинхронность (1 официант, 3 закуски):

0:00 → Подал закуску 1, ждёт ответа
0:05 → Подал закуску 2, ждёт ответа
0:10 → Подал закуску 3, ждёт ответа
0:15 → Закуска 1 готова, он её забирает
0:20 → Закуска 2 готова, он её забирает
0:25 → Закуска 3 готова, он её забирает

Общее время: 3 блюда последовательно, но официант НЕ ЖДЁТ

Практический пример: веб-запросы

Многопоточный подход (плохо):

public void ProcessUrlsMultithread(List<string> urls)
{
    var threads = new List<Thread>();
    
    foreach (var url in urls)
    {
        var thread = new Thread(() => 
        {
            using (var client = new WebClient())
            {
                // Блокирует поток на время загрузки!
                var data = client.DownloadString(url);
                Console.WriteLine($"Загружено: {data.Length} байт");
            }
        });
        
        thread.Start();
        threads.Add(thread);
    }
    
    threads.ForEach(t => t.Join());
}
// Проблема: 1000 потоков для 1000 URL = огромный оверхед

Асинхронный подход (хорошо):

public async Task ProcessUrlsAsync(List<string> urls)
{
    var tasks = urls.Select(async url =>
    {
        using (var client = new HttpClient())
        {
            // НЕ блокирует поток, освобождает его для других операций
            var data = await client.GetStringAsync(url);
            Console.WriteLine($"Загружено: {data.Length} байт");
        }
    });
    
    await Task.WhenAll(tasks);
}
// Решение: 1 поток обрабатывает 1000 URL эффективно

Сравнение параметров

Когда использовать?

Многопоточность:

• CPU-bound операции (вычисления, обработка)
• Машинное обучение, математические расчёты
• Когда нужен истинный параллелизм на многоядерных системах

Асинхронность:

• I/O-bound операции (сеть, БД, файлы)
• Веб-серверы (ASP.NET Core)
• Клиентские приложения (WPF, UWP)
• Когда много одновременных операций

Комбинирование

// Можно использовать оба подхода вместе
public async Task ProcessDataAsync(List<string> urls)
{
    // Асинхронность для загрузки
    var downloadTasks = urls.Select(url => 
        DownloadAsync(url)
    );
    
    var results = await Task.WhenAll(downloadTasks);
    
    // Многопоточность для тяжёлой обработки
    Parallel.ForEach(results, data => 
    {
        var processed = ExpensiveComputation(data);
        Console.WriteLine(processed);
    });
}

Вывод: Для веб-серверов (99% случаев) используй асинхронность. Многопоточность применяй осознанно для CPU-bound задач.