Czy async/await tworzy nowe wątki?
Krótka odpowiedź: NIE, nie automatycznie
To jest jedno z najczęstszych błędnych przekonań w C# - async/await sam z siebie nie tworzy nowego wątku. To jest fundamentalne nieporozumienie, warte dokładnego wyjaśnienia, bo dotyka samego serca modelu asynchroniczności w .NET.
Co faktycznie się dzieje - I/O-bound vs CPU-bound
To rozróżnienie jest kluczowe do zrozumienia całego tematu:
I/O-bound (operacje wejścia/wyjścia) - BRAK nowego wątku
public async Task<Order> GetOrderAsync(int id)
{
var response = await _httpClient.GetAsync($"api/orders/{id}"); // I/O-bound - operacja SIECIOWA
return await response.Content.ReadFromJsonAsync<Order>();
}
Gdy wywołujesz HttpClient.GetAsync(), .NET nie blokuje żadnego wątku, czekając na odpowiedź z sieci. Zamiast tego wykorzystuje I/O Completion Ports (mechanizm systemu operacyjnego) - wątek wraca do puli wątków i jest wolny do obsługi innej pracy, podczas gdy karta sieciowa/system operacyjny asynchronicznie czeka na odpowiedź. Gdy odpowiedź przyjdzie, system operacyjny powiadamia .NET, a runtime pobiera wątek z puli (może to być inny wątek niż ten, który zaczął operację!) do wykonania kontynuacji (ReadFromJsonAsync i dalej).
Kluczowy wniosek: podczas całego czasu czekania na odpowiedź sieciową, żaden wątek nie jest zajęty - to jest właśnie powód, dla którego async I/O jest tak wydajne w Web API pod dużym obciążeniem: 1000 równoczesnych requestów czekających na bazę danych nie blokuje 1000 wątków, tylko może być obsłużone przez np. 10 wątków, które "odskakują" do innej pracy, gdy nie ma co robić.
CPU-bound (operacje intensywne obliczeniowo) - Task.Run faktycznie ZLECA prace do innego wątku
public async Task<decimal> CalculateComplexDiscountAsync(Order order)
{
// TO jest CPU-bound - ciężkie obliczenia, nie I/O
return await Task.Run(() => PerformExpensiveCalculation(order));
}
private decimal PerformExpensiveCalculation(Order order)
{
// np. skomplikowana symulacja, przeszukanie dużego zbioru danych w pamięci
decimal result = 0;
for (int i = 0; i < 10_000_000; i++) { result += Math.Sqrt(i); }
return result;
}
Task.Run() faktycznie zleca wykonanie delegata do wątku z ThreadPool - to jest jedyny scenariusz, w którym można powiedzieć, że "coś tworzy nowy wątek pracy" (a właściwie: pożycza wątek z puli, nie tworzy go od zera przy każdym wywołaniu, bo ThreadPool zarządza pulą i reużywa wątki).
Ważne rozróżnienie: to Task.Run() powoduje użycie wątku z puli, nie sam async/await. await to tylko mechanizm czekania na zakończenie Task-a (I/O-bound albo CPU-bound) bez blokowania wątku wywołującego.
Diagram myślowy - co się dzieje "pod maską"
I/O-bound (HttpClient, EF Core, File I/O):
[Wątek A] → wywołuje operację I/O → ODDAJE wątek do puli (BRAK zajętego wątku podczas czekania)
→ system operacyjny/sprzęt wykonuje pracę
[Wątek B, może inny niż A] ← pobrany z puli, gdy I/O się zakończy → kontynuacja metody
CPU-bound (Task.Run):
[Wątek A] → Task.Run() → ZAJMUJE wątek Z PULI na czas obliczeń (wątek jest FAKTYCZNIE zajęty)
[Wątek B z ThreadPool] → wykonuje obliczenia → zwraca wynik
[Wątek A] → wraca do wykonania po await, gdy obliczenia się zakończą
Dlaczego to rozróżnienie ma praktyczne znaczenie - antywzorzec
// ❌ ANTYWZORZEC - I/O-bound owinięte w Task.Run to strata zasobów
public async Task<Order> GetOrderBadAsync(int id)
{
return await Task.Run(async () => // ❌ NIEPOTRZEBNE - HttpClient.GetAsync JUŻ jest async I/O
{
var response = await _httpClient.GetAsync($"api/orders/{id}");
return await response.Content.ReadFromJsonAsync<Order>();
});
}
// ✅ Poprawnie - I/O-bound BEZ Task.Run, bo HttpClient JUŻ zarządza tym asynchronicznie
public async Task<Order> GetOrderAsync(int id)
{
var response = await _httpClient.GetAsync($"api/orders/{id}");
return await response.Content.ReadFromJsonAsync<Order>();
}
Task.Run() na operacji I/O-bound niepotrzebnie zajmuje wątek z puli na czas, kiedy w rzeczywistości nie trzeba by go zajmować w ogóle - to jest realny problem wydajnościowy w Web API pod dużym obciążeniem, bo marnujesz wątki, które mogłyby obsługiwać inne requesty.
Gdzie Task.Run faktycznie ma sens
// W kontekście UI (WPF) - żeby NIE blokować wątku UI dla ciężkich obliczeń CPU-bound
private async void CalculateButton_Click(object sender, RoutedEventArgs e)
{
IsCalculating = true;
var result = await Task.Run(() => PerformExpensiveCalculation(data)); // ✅ SENSOWNE - CPU-bound, UI thread wolny
ResultText = result.ToString();
IsCalculating = false;
}
To nawiązuje wprost do rozmowy o SynchronizationContext/Dispatcher w WPF - Task.Run jest właściwym narzędziem, gdy chcesz odciążyć wątek UI od kosztownych obliczeń CPU-bound, żeby interfejs nie "zamarzał" - ale w kodzie serwerowym/API, gdzie i tak operujesz na wątkach z ThreadPool, Task.Run na operacji I/O-bound po prostu nie ma sensu i szkodzi wydajności.
Podsumowanie - precyzyjna odpowiedź na rozmowie
async/awaitsam z siebie NIE tworzy nowych wątków. Dla operacji I/O-bound (sieć, dysk, baza danych) .NET wykorzystuje mechanizm I/O Completion Ports systemu operacyjnego - żaden wątek nie jest zajęty w czasie oczekiwania na odpowiedź, co jest właśnie fundamentem skalowalności async w Web API. Nowe (a właściwie: pożyczone zThreadPool) wątki są używane tylko wtedy, gdy jawnie użyjeszTask.Run()do zlecenia pracy CPU-bound - i to jest jedyny scenariusz, w którym "async" faktycznie wiąże się z zajęciem osobnego wątku pracy. Mylenie tych dwóch przypadków (i owijanie I/O-bound w niepotrzebnyTask.Run) jest częstym antywzorcem wydajnościowym.