Çalıştırılabilir C# Dokümanları: Task'lar

Q: C#'ta Task nedir?

Bir Task, gelecekte bitebilecek bir işlemi temsil eder: thread pool'da kod çalıştırmak, bir timer, bir G/Ç isteği. Await edilebilir, tamamlanıp tamamlanmadığını, başarısız olup olmadığını ya da iptal edilip edilmediğini bildirir ve Task ayrıca bir sonuç taşır. Task'lar async/await'in altındaki yapı taşıdır.

Q: C#'ta Task ile Thread arasındaki fark nedir?

Bir Thread, kendi stack'i olan, sizin oluşturup yönettiğiniz bir işletim sistemi thread'idir; başlatması pahalıdır ve değer döndürmez. Bir Task ise işi tanımlar ve Task.Run onu yeniden kullanılabilir thread'lerden oluşan paylaşılan bir havuzda planlar; bir sonuç döndürebilir, istisnaları yayabilir, iptal edilebilir ve await edilebilir. Özel ayarlara sahip, uzun ömürlü, ayrılmış bir thread'e ihtiyacınız yoksa task'ları kullanın.

Q: C#'ta bir Task nasıl iptal edilir?

Bir CancellationTokenSource oluşturun, onun Token'ını işe verin ve kaynak üzerinde Cancel() (ya da CancelAfter(timeout)) çağırın. İş iş birliği yapmalıdır: döngüsünde token.IsCancellationRequested'ı kontrol etmeli ya da token.ThrowIfCancellationRequested() çağırmalı ve token'ı Task.Delay gibi async API'lere iletmelidir. İptal edilmiş bir task'ı await etmek OperationCanceledException fırlatır.

Q: Task.WhenAll ile Task.WhenAny arasındaki fark nedir?

Task.WhenAll her task tamamlandığında tamamlanır ve size tüm sonuçları verir. Task.WhenAny ilk task tamamlanır tamamlanmaz tamamlanır ve o task'ı döndürür. WhenAny bir zaman aşımı eklemenin olağan yoludur: işi Task.Delay ile yarıştırın.

Q: Task.Result neden AggregateException fırlatıyor?

.Result ve .Wait() her başarısızlığı bir AggregateException içine sarar, çünkü bir task genel olarak birkaç istisna tutabilir. await onu açar ve ilk iç istisnayı doğrudan yeniden fırlatır; await'i tercih etmenin bir nedeni budur. Bloklamanız gerekiyorsa .GetAwaiter().GetResult() de orijinal istisnayı fırlatır.

Bir Task, devam eden işi temsil eden bir nesnedir. Bir thread pool thread'inde çalışıyor, bir timer'ı ya da bir ağ cevabını bekliyor olabilir; her durumda bitip bitmediğini sorabilir, sonucunu alabilir, onu bekleyebilir ya da ona daha fazla iş ekleyebilirsiniz. async ve await, task'lar üzerindeki dil sözdizimidir. Bu sayfa Task API'sinin kendisini ve thread'leri ele alır.

Task.Run: thread pool'da iş

Task.Run bir lambda alır ve onu thread pool'a kuyruklar; thread pool, .NET'in her iş için yeni bir thread oluşturmamak için hazırda tuttuğu bir thread kümesidir. Bir Task ya da lambda bir değer döndürüyorsa bir Task<T> döndürür.

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);
    }
}

Çıktı:

Started, completed yet: False
Primes up to 200,000: 17984
Status: RanToCompletion

Result, task bitene kadar çağıran thread'i bloklar. Bir konsol programının Main'inde bu kabul edilebilir, ama async kodun içinde bloklamadan bekleyen int primes = await task; yazardınız. Aynısı sonucu olmayan bir Task için task.Wait() için de geçerlidir.

Task.Run CPU'ya bağlı iş içindir: bir çekirdeği meşgul tutan hesaplamalar. Bir dosya okumak ya da bir web API'si çağırmak gibi G/Ç için kütüphanenin zaten sağladığı async metodu (File.ReadAllTextAsync, HttpClient.GetStringAsync) kullanın ve doğrudan await edin. G/Ç beklerken await edilen bir async çağrı hiçbir thread'i tutmaz; bu yüzden onu Task.Run içine sarmak bir şey kazandırmaz, yalnızca thread pool üzerinden fazladan bir geçiş ekler. Bir pool thread'ini gerçekten meşgul eden durum, File.ReadAllText gibi senkron ve bloklayan bir çağrının Task.Run içine sarılmasıdır: o thread disk ya da ağ yanıt verene kadar boşta bekler.

Aynı anda birkaç task: WhenAll

Bağımsız işi task'lara bölün, hepsini başlatın ve sonuçları Task.WhenAll ile birleştirin. Birkaç çekirdekli bir makinede parçalar paralel çalışır.

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());
    }
}

Çıktı:

Parts: 14999995, 14999999, 15000003, 15000000
Total: 59999997

Her parça kendi aralığında çalışır ve kendi toplamını döndürür, bu yüzden task'lar hiçbir şey paylaşmaz ve lock gerektirmez. WhenAll, thread'ler hangi sırayla bitmiş olursa olsun sonuçları task'ların sırasıyla döndürür. Task'ların paylaşılan durumu güncellemesi gerektiğinde lock sayfasına bakın.

WhenAny ve zaman aşımları

Task.WhenAny, task'larından ilki tamamlandığında tamamlanır ve o task'ı döndürür. Gerçek işi Task.Delay ile yarıştırmak bir zaman aşımı verir:

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();
    }
}

Çıktı:

fast mirror answered after 100 ms
Timed out after 300 ms

WhenAny sonucunu değil kazanan task'ın kendisini döndürür, bu yüzden değeri (ya da başarısız olduysa istisnayı) almak için onu tekrar await edersiniz. Kaybeden task'ların çalışmaya devam ettiğine dikkat edin; WhenAny onları durdurmaz. Yavaş işi gerçekten durdurmak için aşağıda gösterildiği gibi bir token ile iptal edin. .NET 6 ve sonrasında await work.WaitAsync(TimeSpan.FromMilliseconds(300)) aynı zaman aşımını tek bir çağrıda ifade eder.

ContinueWith ile devamlar

await'ten önce, bir task bittikten sonra kod çalıştırmanın yolu ContinueWith'ti. Onu eski kodda hâlâ görürsünüz:

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);
    }
}

Çıktı:

Report total: 42

Her devam önceki task'ı alır ve o tamamlandığında çalışır. await aynı şeyi çok daha az törenle yapar, istisnaları doğal şekilde ele alır ve doğru bağlama döner, bu yüzden yeni kodda onu tercih edin. ContinueWith önceki task başarısız olsa ya da iptal edilse bile çalışır; bu yüzden eski kod, başarısız bir task üzerinde .Result çağırmaktan kaçınmak için t.IsFaulted'i incelemek ya da TaskContinuationOptions vermek zorundadır.

CancellationToken ile iptal

Task'lar iş birliğiyle iptal edilir. Bir CancellationTokenSource bir token verir; işi yapan kod token'ı kontrol eder ve kendini durdurur. Hiçbir şey zorla durdurulmaz.

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();
    }
}

Çıktı:

Cancelled before finishing all 10 orders
Processed 3

Token her katmandan aşağı geçirilir ve Task.Delay, HttpClient ile veritabanı çağrıları gibi async API'ler de onu kabul eder, böylece bir iptal onları beklemenin ortasında durdurur. OperationCanceledException'ı yakalayın; bazı API'lerin fırlattığı TaskCanceledException ondan türer. CancellationTokenSource IDisposable'dır, using bu yüzdendir.

Thread ile Task

Bir Thread, kendiniz oluşturduğunuz bir işletim sistemi thread'idir. Daha ağırdır: her birinin kendi stack'i vardır (Windows'ta varsayılan olarak 1 MB), birini başlatmak ölçülebilir zaman alır ve size hiçbir sonuç ya da istisna yönetimi vermez.

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);
    }
}

Çıktı:

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'e yalnızca havuzun vermediği bir şeye ihtiyacınız olduğunda başvurun: asla bir pool thread'i ödünç almaması gereken uzun süreli bir döngü, belirli bir öncelik ya da COM için tek thread'li bir apartman. Uzun süreli task'lar için Task.Factory.StartNew(work, TaskCreationOptions.LongRunning) task API'sini korurken ayrılmış bir thread alır.

Parallel.For ve Parallel.ForEach

"Bunu her öğeye tüm çekirdekleri kullanarak yap" için System.Threading.Tasks.Parallel elle task oluşturmaktan daha basittir. Aralığı thread'ler arasında bölüştürür ve tüm yinelemeler bittiğinde döner:

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);
    }
}

Örnek çıktı:

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

Görüntü başına satırlar thread'ler onları hangi sırayla çalıştırdıysa o sırayla çıkar ve thread ID'leri çalıştırmadan çalıştırmaya değişir; yalnızca toplam sabittir. Paralel döngülerin doğası budur: yinelemeler birbirinin sırasına bağlı olmamalıdır ve paylaşılan her durum senkronizasyon gerektirir (burada Interlocked.Add). Parallel.ForEach herhangi bir koleksiyon üzerinde aynısını yapar ve .NET 6 async gövdeler için Parallel.ForEachAsync'i ekler.

Yaygın hatalar

Async kodun içinde .Result ya da .Wait(). Bir thread'i bloklar ve UI uygulamalarında deadlock'a yol açabilir; bunun yerine await kullanın.
.Result'ın etrafında orijinal istisna tipini yakalamak. Başarısızlıklar AggregateException içine sarılı gelir; await onları açar.
Ateşle ve unut. Await edilmeyen ya da saklanmayan Task.Run(...) istisnalarını kaybeder.
G/Ç'nin etrafında Task.Run. Bir async metodun etrafında yalnızca thread pool üzerinden fazladan bir geçiş ekler; File.ReadAllText gibi bloklayan bir metodun etrafında ise bekleme boyunca bir pool thread'ini tutar. Async G/Ç metodunu doğrudan await edin.
Token'ı yok saymak. İş onu kontrol etmedikçe bir CancellationToken geçirmek hiçbir şey yapmaz.
Paralel kodda senkronize edilmemiş paylaşılan durum. Interlocked, lock kullanın ya da her task'a kendi verisini verin.

Sıkça Sorulan Sorular

C#'ta Task nedir?

Bir Task, gelecekte bitebilecek bir işlemi temsil eder: thread pool'da kod çalıştırmak, bir timer, bir G/Ç isteği. Await edilebilir, tamamlanıp tamamlanmadığını, başarısız olup olmadığını ya da iptal edilip edilmediğini bildirir ve Task<T> ayrıca bir sonuç taşır. Task'lar async/await'in altındaki yapı taşıdır.

C#'ta Task ile Thread arasındaki fark nedir?

Bir Thread, kendi stack'i olan, sizin oluşturup yönettiğiniz bir işletim sistemi thread'idir; başlatması pahalıdır ve değer döndürmez. Bir Task ise işi tanımlar ve Task.Run onu yeniden kullanılabilir thread'lerden oluşan paylaşılan bir havuzda planlar; bir sonuç döndürebilir, istisnaları yayabilir, iptal edilebilir ve await edilebilir. Özel ayarlara sahip, uzun ömürlü, ayrılmış bir thread'e ihtiyacınız yoksa task'ları kullanın.

Task.Run ne zaman kullanılmalı?

Geçerli thread'in dışına almak istediğiniz CPU'ya bağlı iş için: görüntü işleme, büyük bir hesaplama, bellekteki büyük bir dosyayı parse etmek; özellikle bir arayüzü duyarlı tutmak için. G/Ç'yi Task.Run içine sarmayın: ReadAllTextAsync gibi async G/Ç metotları beklerken thread'i zaten serbest bırakır.

C#'ta bir Task nasıl iptal edilir?

Bir CancellationTokenSource oluşturun, onun Token'ını işe verin ve kaynak üzerinde Cancel() (ya da CancelAfter(timeout)) çağırın. İş iş birliği yapmalıdır: döngüsünde token.IsCancellationRequested'ı kontrol etmeli ya da token.ThrowIfCancellationRequested() çağırmalı ve token'ı Task.Delay gibi async API'lere iletmelidir. İptal edilmiş bir task'ı await etmek OperationCanceledException fırlatır.

Task.WhenAll ile Task.WhenAny arasındaki fark nedir?

Task.WhenAll her task tamamlandığında tamamlanır ve size tüm sonuçları verir. Task.WhenAny ilk task tamamlanır tamamlanmaz tamamlanır ve o task'ı döndürür. WhenAny bir zaman aşımı eklemenin olağan yoludur: işi Task.Delay ile yarıştırın.

Task.Result neden AggregateException fırlatıyor?

.Result ve .Wait() her başarısızlığı bir AggregateException içine sarar, çünkü bir task genel olarak birkaç istisna tutabilir. await onu açar ve ilk iç istisnayı doğrudan yeniden fırlatır; await'i tercih etmenin bir nedeni budur. Bloklamanız gerekiyorsa .GetAwaiter().GetResult() de orijinal istisnayı fırlatır.

İlgili kavramlar