C# Timer: System.Threading.Timer, System.Timers.Timer, PeriodicTimer

Bir timer kodu bir gecikmeden sonra ya da yinelenen bir aralıkla çalıştırır: bir önbelleği her dakika yenilemek, bir taslağı her 30 saniyede kaydetmek, bir servisi yoklamak, bir saati güncellemek. .NET'te birbirine benzeyen ama callback'in nerede çalıştığı ve onları nasıl kontrol ettiğiniz bakımından farklılaşan birkaç timer sınıfı vardır. Bu sayfa her birini ve bir şeyin ne kadar sürdüğünü ölçmek için Stopwatch'ı ele alır.

Hangi timer kullanılmalı

İlk ikisi thread pool thread'lerinde tetiklenir, bu yüzden callback'leri programınızın geri kalanıyla aynı anda, hatta birbirleriyle aynı anda çalışabilir. UI timer'ları UI thread'inde çalışır; kontrollere doğrudan dokunabilmelerinin ve yavaş bir handler'ın pencereyi dondurmasının nedeni budur.

System.Threading.Timer

Constructor callback'i, bir durum nesnesini, ilk tick'ten önceki gecikmeyi ve periyodu alır. Hemen başlar.

using System;
using System.Diagnostics;
using System.Threading;

class Program
{
    static Timer timer;                  // a field keeps the timer alive
    static int ticks = 0;
    static Stopwatch clock = Stopwatch.StartNew();
    static ManualResetEvent done = new ManualResetEvent(false);

    static void OnTick(object state)
    {
        int n = Interlocked.Increment(ref ticks);
        Console.WriteLine("tick " + n + " at ~" + clock.ElapsedMilliseconds / 100 * 100 + " ms");
        if (n == 4)
        {
            timer.Change(Timeout.Infinite, Timeout.Infinite); // stop further ticks
            done.Set();
        }
    }

    static void Main()
    {
        // first tick after 200 ms, then every 300 ms
        timer = new Timer(OnTick, null, 200, 300);
        done.WaitOne();                  // keep Main alive until the 4th tick
        timer.Dispose();
        Console.WriteLine("stopped after " + ticks + " ticks");
    }
}

Örnek çıktı:

tick 1 at ~200 ms
tick 2 at ~500 ms
tick 3 at ~800 ms
tick 4 at ~1100 ms
stopped after 4 ticks

Burada iki ayrıntı önemlidir. Main beklemek zorundadır (done.WaitOne()); bir konsol programı Main döndüğünde çıkar ve timer callback'leri süreci canlı tutmayan arka plan thread'lerinde çalışır. Ve timer statik bir alanda yaşar: hiçbir şeyin referans vermediği bir System.Threading.Timer çöp toplayıcı tarafından toplanabilir ve sonra sessizce tetiklenmeyi bırakır. Bu en çok, bir timer dönen bir metodun içinde yerel bir değişken olarak oluşturulduğunda ısırır.

Change(dueTime, period) timer'ı yeniden planlar; ikisi için de Timeout.Infinite onu duraklatır ve yeni bir çift onu yeniden başlatır. Dispose() onu kalıcı olarak durdurur.

System.Timers.Timer

System.Timers.Timer aynı mekanizmayı event tabanlı bir API'ye sarar: Interval'ı ayarlayın, Elapsed'a abone olun, sonra Start() ve Stop().

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        int saves = 0;
        var autosave = new System.Timers.Timer(250);   // interval in ms
        var finished = new ManualResetEvent(false);

        autosave.Elapsed += (sender, e) =>
        {
            int n = Interlocked.Increment(ref saves);
            Console.WriteLine("autosave #" + n);
            if (n == 3)
            {
                autosave.Stop();
                finished.Set();
            }
        };
        autosave.AutoReset = true;   // repeat (the default); false fires once
        autosave.Start();

        finished.WaitOne();
        autosave.Dispose();
        Console.WriteLine("autosave stopped");
    }
}

Örnek çıktı:

autosave #1
autosave #2
autosave #3
autosave stopped

AutoReset = false tek seferlik bir timer yapar: bir kez tetiklenir ve durur, Start()'ı tekrar çağırmak sonraki tek tick'i planlar. Enabled = true ve false, Start() ve Stop() ile aynıdır. System.Threading'de de bir Timer olduğu için burada tam ad System.Timers.Timer yazılmıştır; iki namespace de içe aktarılmışken çıplak bir Timer belirsizdir ve derlenmez.

System.Timers.Timer'ın ayrıca WinForms'ta Elapsed'ı bir UI thread'ine aktaran bir SynchronizingObject property'si vardır. Uygulamada bunun için UI framework'ünün kendi timer'ı daha basittir.

Callback'ler üst üste biner ve başka thread'lerde çalışır

Yukarıdaki iki sınıf da, önceki callback bitmiş olsun ya da olmasın, planlandığı gibi thread pool'da tetiklenir. Bir callback 3 saniye sürüyorsa ve periyot 1 saniyeyse, üç callback aynı anda çalışır. Bu iki yükümlülük doğurur:

• Callback'in dokunduğu her şey thread-safe olmalıdır. Sayaçlar için (örneklerin yaptığı gibi) Interlocked, daha büyük her şey için bir lock kullanın.
• Önemli olduğunda üst üste binmeye karşı koruma alın. Ya önceki hâlâ çalışırken bir tick'i atlayın ya da üst üste binemeyen bir kalıp kullanın.

Interlocked ile bir atlama koruması:

private int running = 0;

private void OnTick(object state)
{
    if (Interlocked.Exchange(ref running, 1) == 1) return; // previous tick still busy
    try
    {
        SyncOrders();   // slow work
    }
    finally
    {
        Volatile.Write(ref running, 0);
    }
}

İstisnalar diğer tuzaktır. Bir System.Threading.Timer callback'inden kaçan bir istisna süreci çökertir, System.Timers.Timer ise Elapsed handler'larından gelen istisnaları yutar ve başarısızlık fark edilmez. Bir timer callback'inin gövdesini try/catch içine alın ve log'a yazın.

PeriodicTimer ve async döngüler

Async kodda, yinelemeler arasında bekleyen bir döngü en anlaşılır timer'dır: sonraki bekleme ancak iş bittikten sonra başlar, bu yüzden tick'ler asla üst üste binemez ve istisnalar yakalayabileceğiniz yerde ortaya çıkar. .NET 6 tam olarak bunun için PeriodicTimer'ı ekledi:

using var timer = new PeriodicTimer(TimeSpan.FromSeconds(30));

while (await timer.WaitForNextTickAsync(cancellationToken))
{
    await SaveDraftAsync();
}

WaitForNextTickAsync, timer dispose edildikten sonra döngüyü bitiren false döndürür ve token iptal edildiğinde OperationCanceledException fırlatır. Task.Delay etrafındaki bir döngünün aksine bir PeriodicTimer sabit bir ritim korur: iş 2 saniye sürerse sonraki tick yine önceki tick'ten 32 değil 30 saniye sonra gelir.

Kaymanın önemli olmadığı durumlarda her sürümde Task.Delay ile aynı şekil çalışır:

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task PollAsync(CancellationToken token)
    {
        int round = 0;
        try
        {
            while (true)
            {
                round++;
                Console.WriteLine("poll " + round);
                await Task.Delay(200, token);   // wait, or stop early on cancel
            }
        }
        catch (OperationCanceledException)
        {
            Console.WriteLine("polling cancelled after " + round + " rounds");
        }
    }

    static void Main()
    {
        using (var cts = new CancellationTokenSource(700))  // cancel after 700 ms
        {
            PollAsync(cts.Token).GetAwaiter().GetResult();
        }
    }
}

Örnek çıktı:

poll 1
poll 2
poll 3
poll 4
polling cancelled after 4 rounds

İptal Stop()'un yerini alır: döngüye bir token verin ve onu dışarıdan iptal edin. İptal token'ları hakkında daha fazlası için task'lar sayfasına bakın.

Stopwatch ile geçen süreyi ölçmek

Bir timer kodu planlar; Stopwatch kodun ne kadar sürdüğünü ölçer. Yalnızca ileri giden yüksek çözünürlüklü bir saati okur; bu da onu süre ölçmek için doğru araç yapar:

using System;
using System.Diagnostics;
using System.Text;

class Program
{
    static void Main()
    {
        var sw = Stopwatch.StartNew();

        string s = "";
        for (int i = 0; i < 20000; i++) s += "x";      // slow: copies the string each time
        sw.Stop();
        Console.WriteLine("string +=      " + sw.ElapsedMilliseconds + " ms");

        sw.Restart();
        var sb = new StringBuilder();
        for (int i = 0; i < 20000; i++) sb.Append("x");
        string built = sb.ToString();
        sw.Stop();
        Console.WriteLine("StringBuilder  " + sw.ElapsedMilliseconds + " ms");

        Console.WriteLine("Same length: " + (s.Length == built.Length));
        Console.WriteLine("High resolution clock: " + Stopwatch.IsHighResolution);
    }
}

Örnek çıktı:

string +=      64 ms
StringBuilder  0 ms
Same length: True
High resolution clock: True

Start, Stop, Reset ve Restart onu kontrol eder; Elapsed bir TimeSpan'dir, ElapsedMilliseconds ve ElapsedTicks ham sayılar verir. DateTime.Now ile süre ölçmekten kaçının: çözünürlüğü 10 ile 15 ms kadar kaba olabilir ve sistem saati ayarlandığında sıçrar. JIT ısınmasının ve çöp toplamanın tek bir çalıştırmayı bozduğu ciddi benchmark'lar için BenchmarkDotNet kütüphanesini kullanın.

Timer doğruluğu

Bir timer aralığı bir vaat değil, bir alt sınırdır. Windows'ta varsayılan sistem timer çözünürlüğü yaklaşık 15,6 ms'dir, bu yüzden 10 ms'lik bir aralık her 15 ya da 16 ms'de bir tetiklenme eğilimindedir ve meşgul bir makinede bir thread pool callback'i daha da geç başlayabilir. Timer'lar "yaklaşık her N saniyede bir" için doğrudur. Kesin kare zamanlaması ya da medya için bunun için yapılmış API'leri kullanın.

Yaygın hatalar

• Yalnızca yerel bir değişkende saklanan bir System.Threading.Timer. Çöp toplayıcı tarafından toplanıp tetiklenmeyi bırakabilir; onu bir alanda tutun.
• Main'in dönmesine izin vermek. Süreç biter ve timer'ı da beraberinde götürür.
• Belirsiz Timer. System.Threading ve System.Timers ikisi de içe aktarılmışken tam adı yazın.
• Tick'lerin asla üst üste binmediğini varsaymak. İş aralıktan yavaş olduğunda thread pool timer'ları üst üste biner.
• Bir thread pool timer'ından UI kontrollerine dokunmak. UI framework'ünün timer'ını kullanın ya da UI thread'ine geri aktarın.
• Callback'lerde ele alınmayan istisnalar. Süreci çökertirler (Threading.Timer) ya da kaybolurlar (Timers.Timer); yakalayıp log'a yazın.
• Dispose'u unutmak. Timer'lar sistem kaynakları tutar ve dispose edilene kadar tetiklenmeye devam eder.