В чем разница между Thread и Task?

В чем разница между Thread и Task?

Thread и Task — это два разных подхода к асинхронному программированию в .NET. Хотя оба работают с параллелизмом, они решают разные задачи и имеют принципиально разную архитектуру.

Основные различия

Thread — низкоуровневый контроль

// Создание явного потока
var thread = new Thread(() =>
{
    Console.WriteLine($"Выполняется на потоке {Thread.CurrentThread.ManagedThreadId}");
    Thread.Sleep(2000);
    Console.WriteLine("Готово!");
});

thread.Start();  // запуск
thread.Join();   // ожидание завершения

Console.WriteLine("Основной поток продолжает");

Проблемы Thread:

// 1. Исключение убивает поток, не влияя на главный
var thread = new Thread(() =>
{
    throw new InvalidOperationException("Ошибка в потоке!");
});
thread.Start();

// Главный поток не узнает об ошибке!
Console.WriteLine("Главный поток живёт дальше");

// 2. Утечка ресурсов
for (int i = 0; i < 10000; i++)
{
    new Thread(() => Console.WriteLine(i)).Start();  // 10000 потоков! (крах)
}

Task — высокоуровневая абстракция

// Лучше: Task использует ThreadPool
var task = Task.Run(() =>
{
    Console.WriteLine("Выполняется на потоке из пула");
    Thread.Sleep(2000);
    return "Результат";
});

var result = await task;  // ожидание и получение результата
Console.WriteLine($"Результат: {result}");

// 2. Исключения сохраняются
var errorTask = Task.Run(() => throw new Exception("Ошибка!"));

try
{
    await errorTask;
}
catch (Exception ex)
{
    Console.WriteLine($"Поймали: {ex.Message}");
}

async/await с Task

public async Task<string> FetchDataAsync()
{
    using var httpClient = new HttpClient();
    var response = await httpClient.GetAsync("https://api.example.com/data");
    return await response.Content.ReadAsStringAsync();
}

public async Task Main()
{
    var data = await FetchDataAsync();
    Console.WriteLine($"Получены данные: {data}");
}

Почему async/await лучше, чем Thread:

1. Не блокирует поток — во время ожидания I/O поток возвращается в пул
2. Масштабируется — сервер может обработать 10000 одновременных запросов на одном потоке
3. Исключения обрабатываются — try/catch работает нормально
4. Код читаемый — синхронный стиль, но асинхронное выполнение

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

// ❌ ПЛОХО: Thread на каждый запрос (старый подход)
public class OldWebServer
{
    public void HandleRequest(HttpContext context)
    {
        var thread = new Thread(() =>
        {
            var data = FetchFromDatabase();  // I/O блокирует поток
            context.Response.Write(data);
        });
        thread.Start();  // новый поток на каждый запрос
    }
}

// 1000 запросов = 1000 потоков = 1 ГБ памяти!

// ✅ ХОРОШО: async/await (современный подход)
public class ModernWebServer
{
    [HttpGet("/data")]
    public async Task<string> GetData()
    {
        var data = await FetchFromDatabaseAsync();  // поток в пуле
        return data;  // поток возвращается в пул
    }
    
    private async Task<string> FetchFromDatabaseAsync()
    {
        using var conn = new SqlConnection("...");
        await conn.OpenAsync();  // не блокирует поток!
        // ...
        return result;
    }
}

// 10000 запросов = 4 потока (из пула) = минимум памяти

Task.Run vs new Thread

// new Thread
var thread = new Thread(() => LongRunningWork());
thread.Start();  // Создаёт НОВЫЙ поток (дорого)

// Task.Run
Task.Run(() => LongRunningWork());  // Использует пул потоков (дешево)

// Скорость создания:
// new Thread():  ~1000 потоков/сек
// Task.Run():  ~1,000,000 задач/сек

Task с результатом

public async Task<int> CalculateAsync()
{
    return await Task.FromResult(42);
}

var result = await CalculateAsync();  // 42

// Или вычисление
public async Task<int> CalculateAsync()
{
    var result = await Task.Run(() => ExpensiveCalculation());
    return result;
}

private int ExpensiveCalculation()
{
    int sum = 0;
    for (int i = 0; i < 1_000_000_000; i++)
        sum += i;
    return sum;
}

Task.WhenAll для параллелизма

public async Task ProcessMultipleAsync()
{
    var task1 = FetchUserAsync(1);
    var task2 = FetchUserAsync(2);
    var task3 = FetchUserAsync(3);
    
    // Все три выполняются параллельно!
    var results = await Task.WhenAll(task1, task2, task3);
    
    Console.WriteLine($"Получены {results.Length} пользователей");
}

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

• Очень редко!
• Только если нужен явный контроль потока (SetThreadAffinity, приоритет и т.д.)
• Долгоживущие фоновые работники с специальными требованиями

Итог

Используй Task/async-await — это современный стандарт. Thread — это прошлое. Task масштабируется, экономит память, обрабатывает исключения и писать код проще.