Task yapısı, arka planda devam eden bir işlemi temsil eden bir nesnedir. Bu işlem bir thread pool üzerinden yürütülüyor, bir zamanlayıcıyı bekliyor ya da ağdan yanıt gelmesini bekliyor olabilir. Task nesneleri sayesinde işlemin tamamlanıp tamamlanmadığını sorgulayabilir, sonucunu alabilir, işlemi bekleyebilir veya ona yeni görevler ekleyebilirsiniz. async ve await anahtar kelimeleri, task'ları daha rahat yönetmemizi sağlayan dil özellikleridir. Bu yazıda Task API'sinin kendisine ve thread (iş parçacığı) kullanımına odaklanacağız.Task.Run ile Thread Pool Kullanımı
Task.Run, kendisine verilen bir lambda ifadesini thread pool'a kuyruklar. Thread pool, .NET'in her yeni işlem için ayrı bir thread oluşturma maliyetinden kaçınmak amacıyla hazırda tuttuğu bir thread kümesidir. Eğer işlem bir değer döndürüyorsa, sonuç olarak bir Task<T> nesnesi üretilir.
C#:
using System;
using System.Threading.Tasks;
class Program
{
static int CountPrimes(int max)
{
int count = 0;
for (int n = 2; n <= max; n++)
{
bool prime = true;
for (int d = 2; d * d <= n; d++)
{
if (n % d == 0) { prime = false; break; }
}
if (prime) count++;
}
return count;
}
static void Main()
{
Task<int> task = Task.Run(() => CountPrimes(200000));
Console.WriteLine("Started, completed yet: " + task.IsCompleted);
int primes = task.Result; // blocks until the task finishes
Console.WriteLine("Primes up to 200,000: " + primes);
Console.WriteLine("Status: " + task.Status);
}
}
Kodu çalıştırdığınızda şu çıktıyı alırsınız:
Kod:
Started, completed yet: False
Primes up to 200,000: 17984
Status: RanToCompletion
Result özelliğini çağırdığınızda, ilgili task tamamlanana kadar çağıran thread bloklanır. Bu durum konsol uygulamalarının Main metodunda kabul edilebilir olsa da, asenkron kodlarda bloklama yapmamak için int primes = await task; şeklinde bir kullanım tercih etmelisiniz. Sonuç döndürmeyen task'lar için kullanılan task.Wait() metodu da benzer şekilde thread'i bloklar.Task.Run temel olarak işlemciyi yoğun kullanan (CPU-bound) hesaplamalar için uygundur. Dosya okuma veya web API çağrıları gibi G/Ç (I/O) işlemleri için kütüphanelerin sunduğu yerleşik asenkron metodlar (File.ReadAllTextAsync veya HttpClient.GetStringAsync gibi) kullanılmalı ve doğrudan await edilmelidir. G/Ç işlemleri sırasında await kullanımı herhangi bir thread'i meşgul etmez; dolayısıyla bu tür işlemleri Task.Run ile sarmalamak performans artışı sağlamaz, aksine thread pool üzerinden gereksiz bir geçiş ekler. Ancak File.ReadAllText gibi senkron ve bloklayan bir çağrıyı Task.Run içine koyarsanız, ilgili thread yanıt gelene kadar boşta bekleyerek kaynak tüketir.Çoklu Task Yönetimi: WhenAll
Birbirinden bağımsız işleri ayrı task'lara bölüp hepsini başlatabilir ve sonuçlarını
Task.WhenAll ile tek seferde toplayabilirsiniz. Çok çekirdekli sistemlerde bu parçalar paralel olarak yürütülür.
C#:
using System;
using System.Linq;
using System.Threading.Tasks;
class Program
{
static long SumRange(int from, int to)
{
long sum = 0;
for (int i = from; i < to; i++) sum += i % 7;
return sum;
}
static void Main()
{
int chunks = 4, size = 5000000;
Task<long>[] parts = Enumerable.Range(0, chunks)
.Select(c => Task.Run(() => SumRange(c * size, (c + 1) * size)))
.ToArray();
long[] results = Task.WhenAll(parts).Result;
Console.WriteLine("Parts: " + string.Join(", ", results));
Console.WriteLine("Total: " + results.Sum());
}
}
Kodu çalıştırdığınızda sonuç şöyle olur:
Kod:
Parts: 14999995, 14999999, 15000003, 15000000
Total: 59999997
Her bir parça kendi veri aralığında çalıştığı ve sonucu kendi döndürdüğü için task'lar arasında veri paylaşımı olmaz, bu da
lock mekanizmasına olan ihtiyacı ortadan kaldırır. WhenAll, task'lar hangi sırayla tamamlanırsa tamamlansın, sonuçları task'ların tanımlanma sırasına göre döndürür. Eğer task'ların ortak bir durumu güncellemesi gerekiyorsa lock konusuna göz atmalısınız.WhenAny ve Zaman Aşımı İşlemleri
Task.WhenAny metodu, kendisine verilen task'lardan ilk tamamlanan olduğunda sonuçlanır ve tamamlanan o task'ı geri döndürür. Gerçek işi Task.Delay ile yarıştırarak bir zaman aşımı (timeout) mekanizması kurabilirsiniz:
C#:
using System;
using System.Threading.Tasks;
class Program
{
static async Task<string> QueryServerAsync(string name, int ms)
{
await Task.Delay(ms);
return name + " answered after " + ms + " ms";
}
static async Task RunAsync()
{
Task<string> fast = QueryServerAsync("fast mirror", 100);
Task<string> slow = QueryServerAsync("main server", 800);
Task<string> first = await Task.WhenAny(fast, slow);
Console.WriteLine(await first);
Task<string> work = QueryServerAsync("report service", 2000);
Task timeout = Task.Delay(300);
if (await Task.WhenAny(work, timeout) == timeout)
{
Console.WriteLine("Timed out after 300 ms");
}
}
static void Main()
{
RunAsync().GetAwaiter().GetResult();
}
}
Kodu çalıştırdığınızda şu çıktıyı görürsünüz:
Kod:
fast mirror answered after 100 ms
Timed out after 300 ms
WhenAny doğrudan sonucu değil, kazanan task nesnesini döndürdüğü için değerini almak (veya olası bir hatayı yakalamak) adına onu tekrar await etmeniz gerekir. Önemli bir nokta; WhenAny diğer task'ları durdurmaz, onlar arka planda çalışmaya devam eder. Yavaş ilerleyen işlemleri gerçekten sonlandırmak için bir token kullanarak iptal işlemi yapmalısınız. .NET 6 ve sonrasında await work.WaitAsync(TimeSpan.FromMilliseconds(300)) ifadesi, aynı zaman aşımı mantığını tek bir çağrıyla gerçekleştirmenizi sağlar.ContinueWith ile Devam İşlemleri
await yapısı yaygınlaşmadan önce, bir task tamamlandığında başka bir kod bloğunu çalıştırmak için ContinueWith kullanılırdı. Eski projelerde hâlâ bu yapıya rastlayabilirsiniz:
C#:
using System;
using System.Threading.Tasks;
class Program
{
static void Main()
{
Task<int> load = Task.Run(() => 21);
Task<string> report = load
.ContinueWith(t => t.Result * 2)
.ContinueWith(t => "Report total: " + t.Result);
Console.WriteLine(report.Result);
}
}
Kodu çalıştırdığınızda çıktı şöyledir:
Kod:
Report total: 42
Her bir devam işlemi, kendisinden önceki task bittiğinde tetiklenir.
await ise aynı işlemi çok daha sade bir şekilde yapar, istisnaları daha doğal yönetir ve doğru bağlama (context) geri döner; bu nedenle yeni kodlarda await tercih edilmelidir. ContinueWith, önceki task başarısız olsa veya iptal edilse bile çalışmaya devam eder. Bu yüzden eski kodlarda, hatalı bir task üzerinde .Result çağırıp programı çökertmemek için t.IsFaulted kontrolü yapılır veya TaskContinuationOptions kullanılır.CancellationToken Kullanarak İptal Etme
Task'ların iptali "iş birliğine dayalı" (cooperative) bir şekilde gerçekleşir.
CancellationTokenSource üzerinden bir token oluşturulur; işlemi yürüten kod bu token'ı düzenli olarak kontrol eder ve iptal sinyali geldiğinde kendi kendini durdurur. Hiçbir işlem dışarıdan zorla sonlandırılmaz.
C#:
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static async Task<int> ProcessOrdersAsync(int count, CancellationToken token)
{
int done = 0;
for (int i = 0; i < count; i++)
{
token.ThrowIfCancellationRequested(); // stop between items
await Task.Delay(100, token); // pass the token on
done++;
}
return done;
}
static async Task RunAsync()
{
using (var cts = new CancellationTokenSource())
{
cts.CancelAfter(350); // cancel in 350 ms
try
{
int n = await ProcessOrdersAsync(10, cts.Token);
Console.WriteLine("Processed " + n);
}
catch (OperationCanceledException)
{
Console.WriteLine("Cancelled before finishing all 10 orders");
}
}
using (var cts = new CancellationTokenSource())
{
int n = await ProcessOrdersAsync(3, cts.Token); // never cancelled
Console.WriteLine("Processed " + n);
}
}
static void Main()
{
RunAsync().GetAwaiter().GetResult();
}
}
Kodu çalıştırdığınızda çıktı şöyledir:
Kod:
Cancelled before finishing all 10 orders
Processed 3
Bu token tüm katmanlara iletilir.
Task.Delay veya HttpClient üzerinden yapılan veritabanı çağrıları gibi asenkron API'ler de bu token'ı kabul ettiği için, iptal işlemi bekleme aşamasındaki süreçleri de durdurabilir. Hata yönetimi için OperationCanceledException yakalanmalıdır; bazı API'lerin fırlattığı TaskCanceledException zaten bu sınıftan türemiştir. CancellationTokenSource sınıfı IDisposable olduğu için using bloğu ile kullanılması uygundur.Thread ve Task Arasındaki Farklar
Bir
Thread, doğrudan işletim sistemi düzeyinde oluşturulan bir iş parçacığıdır. Task'lara göre daha ağırdır; çünkü her birinin kendine ait bir stack alanı vardır (Windows'ta varsayılan 1 MB), başlatılmaları zaman alır ve yerleşik bir sonuç döndürme veya hata yönetimi mekanizması sunmazlar.
C#:
using System;
using System.Threading;
class Program
{
static void Main()
{
int result = 0;
var worker = new Thread(() =>
{
Thread.Sleep(100);
result = 6 * 7;
});
worker.Start();
Console.WriteLine("Thread started");
worker.Join(); // wait for it to finish
Console.WriteLine("Result: " + result);
}
}
Kodu çalıştırdığınızda şu çıktılar alınır:
Kod:
Thread started
Result: 42
Thread | Task | |
|---|---|---|
| Çalıştığı yer | Yeni, ayrılmış bir OS thread'i | Bir pool thread'i (ya da G/Ç için hiç thread) |
| Başlatma maliyeti | Yüksek | Düşük |
| Sonuç değeri | Yok, bir değişken paylaşın | Task<T>.Result / await |
| İstisnalar | Ele alınmayanlar süreci çökertir | Task'ta saklanır, await'te yeniden fırlatılır |
| İptal | Elle bayraklar | Yerleşik CancellationToken |
| Onu beklemek | Join() | await, Wait(), WhenAll |
Thread kullanımı sadece thread pool'un yetersiz kaldığı özel durumlarda tercih edilmelidir: Örneğin, pool'dan bir thread'i uzun süre işgal etmemesi gereken uzun döngüler, özel öncelik gereksinimleri veya COM için tek thread'li apartman (STA) gereklilikleri. Uzun süreli işlemler için Task.Factory.StartNew(work, TaskCreationOptions.LongRunning) kullanmak, Task API'sinin avantajlarını korurken ayrılmış bir thread almanızı sağlar.Parallel.For ve Parallel.ForEach Kullanımı
Belirli bir işlemi tüm çekirdekleri kullanarak her öğe için tekrarlamak istiyorsanız,
System.Threading.Tasks.Parallel sınıfı manuel task oluşturmaktan çok daha pratiktir. Bu yapı, işlem aralığını thread'ler arasında paylaştırır ve tüm tekrarlar bittiğinde kontrolü geri verir:
C#:
using System;
using System.Threading;
using System.Threading.Tasks;
class Program
{
static void Main()
{
int[] sizes = { 120, 340, 90, 410, 275, 60 };
long totalPixels = 0;
Parallel.For(0, sizes.Length, i =>
{
long pixels = (long)sizes[i] * sizes[i]; // "process" image i
Interlocked.Add(ref totalPixels, pixels); // thread-safe add
Console.WriteLine("image " + i + " on thread " + Thread.CurrentThread.ManagedThreadId);
});
Console.WriteLine("Total pixels: " + totalPixels);
}
}
Kodu çalıştırdığınızda örnek çıktı şöyle olabilir:
Kod:
image 4 on thread 7
image 3 on thread 6
image 5 on thread 8
image 0 on thread 1
image 1 on thread 4
image 2 on thread 5
Total pixels: 385425
Çıktıdaki satırların sırası, thread'lerin işlem sırasına göre değişir ve thread ID'leri her çalıştırmada farklılık gösterebilir; değişmeyen tek şey toplam sonuçtur. Paralel döngülerin doğası gereği, tekrarlar birbirinin sırasına bağımlı olmamalıdır. Ayrıca paylaşılan bir durum güncellenecekse senkronizasyon (örneğin
Interlocked.Add) şarttır. Parallel.ForEach aynı mantığı koleksiyonlar için sunar; .NET 6 ile birlikte asenkron gövdeler için Parallel.ForEachAsync özelliği de eklenmiştir.Sık Yapılan Hatalar
• Asenkron kod içerisinde
.Result veya .Wait() kullanmak. Bu durum thread'i bloklar ve özellikle UI uygulamalarında deadlock (kilitlenme) riskine yol açar; bunun yerine await kullanılmalıdır.•
.Result kullanımında orijinal hata tipini yakalamaya çalışmak. Hatalar AggregateException içerisine sarılmış olarak gelir; await kullanımı ise bu hataları doğrudan açar.• "Ateşle ve unut" (fire-and-forget) yaklaşımı. Beklenmeyen veya referansı saklanmayan
Task.Run(...) işlemleri sırasında oluşan istisnalar kaybolur.• G/Ç işlemleri için
Task.Run kullanmak. Bir asenkron metodun etrafına sarıldığında sadece gereksiz bir thread pool geçişi ekler; File.ReadAllText gibi senkron metodlarda ise işlem tamamlanana kadar bir thread'i boşuna meşgul eder. Asenkron G/Ç metodlarını doğrudan await edin.• İptal token'ını görmezden gelmek. İşlemi yapan kod token'ı kontrol etmediği sürece,
CancellationToken göndermek hiçbir sonuç vermez.• Paralel kodlarda senkronize edilmemiş ortak veri kullanımı. Bu tür durumlarda
Interlocked veya lock kullanın ya da her task'ın kendi verisiyle çalışmasını sağlayın.