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

Timer uruchamia kod po opóźnieniu albo w powtarzającym się interwale: odświeża cache co minutę, zapisuje szkic co 30 sekund, odpytuje usługę, aktualizuje zegar. .NET ma kilka klas timerów, które wyglądają podobnie, ale różnią się tym, gdzie działa callback i jak nimi sterujesz. Ta strona omawia każdą z nich oraz Stopwatch do mierzenia, ile coś trwało.

Którego timera użyć

Pierwsze dwa uruchamiają się w wątkach z puli, więc ich callbacki mogą działać jednocześnie z resztą programu, a nawet jednocześnie ze sobą. Timery interfejsu działają w wątku interfejsu, dlatego mogą bezpośrednio zmieniać kontrolki i dlatego wolna obsługa zamraża okno.

System.Threading.Timer

Konstruktor przyjmuje callback, obiekt stanu, opóźnienie przed pierwszym tyknięciem i okres. Timer startuje od razu.

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

Przykładowy wynik:

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

Ważne są tu dwa szczegóły. Main musi czekać (done.WaitOne()); program konsolowy kończy się, gdy Main zwraca sterowanie, a callbacki timera działają w wątkach tła, które nie utrzymują procesu przy życiu. Poza tym timer żyje w polu statycznym: System.Threading.Timer, do którego nic się nie odwołuje, może zostać usunięty przez odśmiecacz, a wtedy po cichu przestaje działać. Najczęściej zdarza się to, gdy timer jest tworzony jako zmienna lokalna w metodzie, która się kończy.

Change(dueTime, period) zmienia harmonogram timera; Timeout.Infinite dla obu wartości go wstrzymuje, a nowa para uruchamia ponownie. Dispose() zatrzymuje go na dobre.

System.Timers.Timer

System.Timers.Timer opakowuje ten sam mechanizm w API oparte na zdarzeniach: ustaw Interval, zasubskrybuj Elapsed, a potem Start() i 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");
    }
}

Przykładowy wynik:

autosave #1
autosave #2
autosave #3
autosave stopped

AutoReset = false tworzy timer jednorazowy: uruchamia się raz i zatrzymuje, a ponowne wywołanie Start() planuje kolejne pojedyncze tyknięcie. Enabled = true i false to to samo co Start() i Stop(). Pełna nazwa System.Timers.Timer jest tu zapisana w całości, bo System.Threading też ma Timer; przy zaimportowaniu obu przestrzeni nazw samo Timer jest niejednoznaczne i się nie kompiluje.

System.Timers.Timer ma też właściwość SynchronizingObject, która w WinForms przenosi Elapsed do wątku interfejsu. W praktyce prostszy jest do tego własny timer frameworka interfejsu.

Callbacki nakładają się i działają w innych wątkach

Obie powyższe klasy uruchamiają się w puli wątków zgodnie z harmonogramem, niezależnie od tego, czy poprzedni callback się zakończył. Jeśli callback trwa 3 sekundy, a okres wynosi 1 sekundę, trzy callbacki działają naraz. To rodzi dwa obowiązki:

• Wszystko, czego dotyka callback, musi być bezpieczne wątkowo. Do liczników używaj Interlocked (tak jak przykłady), a do czegoś większego lock.
• Chroń się przed nakładaniem, gdy ma to znaczenie. Pomiń tyknięcie, gdy poprzednie jeszcze trwa, albo użyj wzorca, który nie może się nakładać.

Ochrona przez pomijanie z Interlocked:

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

Drugą pułapką są wyjątki. Wyjątek, który wydostanie się z callbacku System.Threading.Timer, wyłącza proces, a System.Timers.Timer połyka wyjątki z obsługi Elapsed, więc błąd przechodzi niezauważony. Opakuj ciało callbacku timera w try/catch i zapisuj błędy w logu.

PeriodicTimer i pętle asynchroniczne

W kodzie asynchronicznym najczytelniejszym timerem jest pętla, która czeka między iteracjami: następne czekanie zaczyna się dopiero po zakończeniu pracy, więc tyknięcia nigdy się nie nakładają, a wyjątki pojawiają się tam, gdzie możesz je złapać. .NET 6 dodał do tego właśnie PeriodicTimer:

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

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

WaitForNextTickAsync zwraca false po zwolnieniu timera, co kończy pętlę, i rzuca OperationCanceledException, gdy token zostanie anulowany. W przeciwieństwie do pętli wokół Task.Delay PeriodicTimer utrzymuje stały rytm: jeśli praca trwa 2 sekundy, następne tyknięcie i tak przychodzi 30 sekund po poprzednim tyknięciu, a nie po 32.

W każdej wersji ten sam kształt z Task.Delay działa, gdy przesunięcie w czasie nie ma znaczenia:

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

Przykładowy wynik:

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

Anulowanie zastępuje Stop(): przekaż token do pętli i anuluj go z zewnątrz. Więcej o tokenach anulowania znajdziesz na stronie o taskach.

Mierzenie upływu czasu przez Stopwatch

Timer planuje kod; Stopwatch mierzy, ile kod trwał. Odczytuje zegar o wysokiej rozdzielczości, który porusza się tylko do przodu, co czyni go właściwym narzędziem do pomiaru czasu:

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

Przykładowy wynik:

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

Sterują nim Start, Stop, Reset i Restart; Elapsed to TimeSpan, a ElapsedMilliseconds i ElapsedTicks dają surowe liczby. Unikaj mierzenia czasu przez DateTime.Now: jego rozdzielczość może wynosić nawet od 10 do 15 ms i skacze przy korekcie zegara systemowego. Do poważnych benchmarków, w których rozgrzewanie JIT i odśmiecanie zniekształcają pojedyncze uruchomienie, użyj biblioteki BenchmarkDotNet.

Dokładność timerów

Interwał timera to minimum, a nie obietnica. W Windows domyślna rozdzielczość zegara systemowego to około 15,6 ms, więc interwał 10 ms zwykle uruchamia się co 15 lub 16 ms, a na obciążonej maszynie callback z puli wątków może wystartować jeszcze później. Timery pasują do zadań typu "mniej więcej co N sekund". Do precyzyjnego odmierzania klatek albo multimediów używaj API do tego przeznaczonych.

Częste błędy

• System.Threading.Timer przechowywany tylko w zmiennej lokalnej. Może zostać usunięty przez odśmiecacz i przestać działać; trzymaj go w polu.
• Pozwolenie, żeby Main się zakończył. Proces się kończy i zabiera timer ze sobą.
• Niejednoznaczny Timer. Gdy zaimportowane są i System.Threading, i System.Timers, pisz pełną nazwę.
• Zakładanie, że tyknięcia nigdy się nie nakładają. Timery z puli wątków nakładają się, gdy praca jest wolniejsza niż interwał.
• Zmienianie kontrolek interfejsu z timera z puli wątków. Użyj timera frameworka interfejsu albo przenieś wywołanie z powrotem do wątku interfejsu.
• Nieobsłużone wyjątki w callbackach. Wyłączają proces (Threading.Timer) albo znikają (Timers.Timer); łap je i zapisuj w logu.
• Zapominanie o Dispose. Timery trzymają zasoby systemowe i działają, dopóki nie zostaną zwolnione.