Timer ב-C#: System.Threading.Timer, System.Timers.Timer ו-PeriodicTimer

טיימר מריץ קוד אחרי השהיה או במרווח חוזר: רענון מטמון כל דקה, שמירת טיוטה כל 30 שניות, תשאול של שירות, עדכון שעון. ל-.NET יש כמה מחלקות טיימר שנראות דומות אבל שונות במקום שבו ה-callback רץ ובדרך שבה שולטים בהן. העמוד הזה מכסה כל אחת מהן, ובנוסף את Stopwatch למדידת משך הזמן שמשהו לקח.

באיזה טיימר להשתמש

שני הראשונים פועלים על תהליכונים ממאגר התהליכונים, כך שה-callbacks שלהם יכולים לרוץ באותו זמן כמו שאר התוכנית, ואפילו באותו זמן זה כמו זה. טיימרי הממשק רצים על תהליכון הממשק, ולכן הם יכולים לגעת בפקדים ישירות, ולכן גם מטפל איטי מקפיא את החלון.

System.Threading.Timer

הבנאי מקבל את ה-callback, אובייקט מצב, את ההשהיה לפני ה-tick הראשון ואת המחזור. הוא מתחיל מיד.

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

פלט לדוגמה:

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

שני פרטים חשובים כאן. Main חייבת לחכות (done.WaitOne()); תוכנית קונסולה מסתיימת כש-Main חוזרת, ו-callbacks של טיימר רצים על תהליכוני רקע שלא משאירים את התהליך בחיים. והטיימר חי בשדה סטטי: System.Threading.Timer ששום דבר לא מפנה אליו יכול להיאסף על ידי אוסף הזבל, ואז הוא מפסיק לפעול בשקט. זה קורה בעיקר כשטיימר נוצר כמשתנה מקומי בתוך מתודה שחוזרת.

Change(dueTime, period) מתזמנת את הטיימר מחדש; Timeout.Infinite בשניהם משהה אותו, וזוג ערכים חדש מפעיל אותו שוב. Dispose() עוצרת אותו לתמיד.

System.Timers.Timer

System.Timers.Timer עוטף את אותו מנגנון ב-API מבוסס אירועים: מגדירים Interval, נרשמים ל-Elapsed, ואז Start() ו-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");
    }
}

פלט לדוגמה:

autosave #1
autosave #2
autosave #3
autosave stopped

AutoReset = false יוצר טיימר חד-פעמי: הוא פועל פעם אחת ונעצר, וקריאה חוזרת ל-Start() מתזמנת את ה-tick הבודד הבא. Enabled = true ו-false זהים ל-Start() ול-Stop(). השם המלא System.Timers.Timer כתוב כאן כי גם ב-System.Threading יש Timer; כששני מרחבי השמות מיובאים, Timer לבד הוא דו-משמעי ולא מתקמפל.

ל-System.Timers.Timer יש גם מאפיין SynchronizingObject שמעביר את Elapsed לתהליכון ממשק ב-WinForms. בפועל, הטיימר של ספריית הממשק עצמה פשוט יותר לשם כך.

callbacks חופפים ורצים על תהליכונים אחרים

שתי המחלקות שלמעלה פועלות על מאגר התהליכונים, בזמן, בין אם ה-callback הקודם הסתיים ובין אם לא. אם callback לוקח 3 שניות והמחזור הוא שנייה אחת, שלושה callbacks רצים בבת אחת. זה יוצר שתי חובות:

• כל מה שה-callback נוגע בו חייב להיות בטוח לתהליכונים. השתמשו ב-Interlocked למונים (כמו בדוגמאות) וב-lock לכל דבר גדול יותר.
• הגנו מפני חפיפה כשזה חשוב. או שמדלגים על tick בזמן שהקודם עדיין רץ, או שמשתמשים בדפוס שלא יכול לחפוף.

הגנת דילוג עם 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);
    }
}

חריגות הן המלכודת השנייה. חריגה שבורחת מ-callback של System.Threading.Timer מפילה את התהליך, בעוד ש-System.Timers.Timer בולע חריגות ממטפלי Elapsed כך שהכישלון עובר בלי שמישהו ישים לב. עטפו את הגוף של callback של טיימר ב-try/catch ורשמו ללוג.

PeriodicTimer ולולאות אסינכרוניות

בקוד אסינכרוני, לולאה שמחכה בין איטרציות היא הטיימר הברור ביותר: ההמתנה הבאה מתחילה רק אחרי שהעבודה הסתיימה, כך ש-ticks לעולם לא חופפים, וחריגות צצות במקום שבו אפשר לתפוס אותן. .NET 6 הוסיפה את PeriodicTimer בדיוק לשם כך:

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

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

WaitForNextTickAsync מחזירה false ברגע שהטיימר משוחרר, וזה מסיים את הלולאה, וזורקת OperationCanceledException כשה-token מבוטל. בניגוד ללולאה סביב Task.Delay, PeriodicTimer שומר על קצב קבוע: אם העבודה לוקחת 2 שניות, ה-tick הבא עדיין מגיע 30 שניות אחרי ה-tick הקודם, לא 32.

בכל גרסה, אותה צורה עם Task.Delay עובדת כשסטייה בזמן לא משנה:

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

פלט לדוגמה:

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

ביטול מחליף את Stop(): מעבירים token ללולאה ומבטלים אותו מבחוץ. ראו tasks להרחבה על cancellation tokens.

מדידת זמן שעבר עם Stopwatch

טיימר מתזמן קוד; Stopwatch מודד כמה זמן קוד לקח. הוא קורא שעון ברזולוציה גבוהה שנע רק קדימה, ולכן הוא הכלי הנכון למדידת זמנים:

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

פלט לדוגמה:

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

Start, Stop, Reset ו-Restart שולטים בו; Elapsed הוא TimeSpan, ו-ElapsedMilliseconds ו-ElapsedTicks נותנים מספרים גולמיים. הימנעו ממדידת זמן עם DateTime.Now: הרזולוציה שלו יכולה להיות גסה עד 10 עד 15 ms, והוא קופץ כשמכוונים את שעון המערכת. לבנצ'מרקים רציניים, שבהם חימום ה-JIT ואיסוף הזבל מעוותים הרצה בודדת, השתמשו בספרייה BenchmarkDotNet.

דיוק של טיימרים

מרווח של טיימר הוא מינימום, לא הבטחה. ב-Windows רזולוציית ברירת המחדל של טיימר המערכת היא בערך 15.6 ms, כך שמרווח של 10 ms נוטה לפעול כל 15 או 16 ms, ובמחשב עמוס callback ממאגר התהליכונים יכול להתחיל אפילו מאוחר יותר. טיימרים מתאימים ל"בערך כל N שניות". לתזמון פריימים מדויק או למדיה, השתמשו ב-APIs שנבנו לשם כך.

טעויות נפוצות

• System.Threading.Timer שנשמר רק במשתנה מקומי. הוא יכול להיאסף על ידי אוסף הזבל ולהפסיק לפעול; שמרו אותו בשדה.
• לתת ל-Main לחזור. התהליך מסתיים ולוקח איתו את הטיימר.
• Timer דו-משמעי. כש-System.Threading וגם System.Timers מיובאים, כתבו את השם המלא.
• הנחה ש-ticks לעולם לא חופפים. טיימרים של מאגר התהליכונים חופפים כשהעבודה איטית מהמרווח.
• נגיעה בפקדי ממשק מטיימר של מאגר התהליכונים. השתמשו בטיימר של ספריית הממשק או העבירו את הקריאה חזרה לתהליכון הממשק.
• חריגות שלא טופלו ב-callbacks. הן מפילות את התהליך (Threading.Timer) או נעלמות (Timers.Timer); תפסו ורשמו ללוג.
• שכחה של Dispose. טיימרים מחזיקים משאבי מערכת וממשיכים לפעול עד שמשחררים אותם.