c# - CPU 使用率过高

Question

我正在处理一个问题。事实上，我需要在我的程序中使用不同的计时器，而来自 Framework .Net 的计时器并没有达到我的预期。所以我决定创建自己的 Timer，但是我的 Timer 使用了太多的 CPU。这是我的代码:

using System;
using System.Threading;

namespace XXXXXXX.Common.Types
{
public delegate void TimerFinishedEventHandler(object sender, EventArgs e);

class Timer
{
    #region Attributes
    private long m_InitialTickCount;
    private long m_Interval;
    private Thread m_Thread;
    private bool m_Enabled;
    #endregion

    #region Events
    public event TimerFinishedEventHandler Finished;
    #endregion

    #region Constructors
    public Timer(long interval, TimerFinishedEventHandler e)
    {
        Finished += e;
        m_Interval = interval;
        Start(m_Interval);
    }
    #endregion

    #region Public methods
    /// <summary>
    /// Start the timer thread.
    /// </summary>
    public void Start(long interval)
    {
        m_Interval = interval;
        m_Enabled = true;
        m_InitialTickCount = Environment.TickCount;

        if (m_Thread == null)
        {
            m_Thread = new Thread(Check);
            m_Thread.Start();
        }
    }

    /// <summary>
    /// Stop the Timer.
    /// </summary>
    public void Stop()
    {
        m_Enabled = false;
    }

    /// <summary>
    /// Restart the Timer.
    /// </summary>
    public void Restart()
    {
        m_InitialTickCount = Environment.TickCount;
    }
    #endregion

    #region Private methods
    /// <summary>
    /// Check if the timer is finished or not.
    /// </summary>
    private void Check()
    {
        while (true)
        {
            if (!m_Enabled)
                return;

            if (Environment.TickCount > m_InitialTickCount + m_Interval)
            {
                OnFinished(EventArgs.Empty);
                return;
            }
        }
    }

    /// <summary>
    /// Called when the Timer is Finished.
    /// </summary>
    /// <param name="e">Event</param>
    protected virtual void OnFinished(EventArgs e)
    {
        if (Finished != null)
            Finished(this, e);
    }
    #endregion
}
}

有没有人有解决办法？因为当我启动我的程序时，创建了 2 或 3 个计时器，另一个线程运行并且我的 CPU 100% 使用。

Answer 1

您绝对没有理由不能拥有多个计时器。我的程序有数百 个计时器，并且在任何时候它们中的一小部分实际上可以工作。计时器的要点在于它们允许您安排周期性操作并且不消耗任何 CPU 资源，除非实际正在处理操作。也就是说，如果您将计时器设置为每分钟计时一次，则该计时器不占用线程，不消耗任何内存(超出计时器句柄和回调地址的 token 数量)，并且不消耗任何 CPU 资源。只有当计时器每分钟“滴答”一次时，才会分配一个线程为其执行代码。通常这是一个已经存在的池线程，因此线程启动时间可以忽略不计。

使用定时器非常简单:您创建一个方法让定时器执行，然后安排定时器运行它。例如:

System.Threading.Timer myTimer = 
    new System.Threading.Timer(MyTimerProc, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));

void MyTimerProc(object state)
{
    // do something here
}

你可以有另一个计时器，每 30 秒计时一次，并执行不同的计时器过程:

System.Threading.Timer myOtherTimer = 
    new System.Threading.Timer(MyOtherTimerProc, null, TimeSpan.FromMinutes(1), TimeSpan.FromMinutes(1));

void MyOtherTimerProc(object state)
{
    // do something else here
}

计时器不会互相干扰。当然，如果定时器过程中的代码修改了共享数据(例如，两个过程都尝试更新列表或字典)，那么您必须同步访问该共享数据或使用并发数据结构。

如果您的计时器 proc 中的处理时间长于计时器周期，您可能会遇到重入问题。如果 MyTimerProc 中的处理时间超过 60 秒，则可能会出现另一个计时器滴答，现在您有两个线程执行该计时器过程。如果您的代码未设置为处理它，则可能会导致许多不同类型的问题。通常，您可以通过使计时器一次性并在每个处理周期结束时重新启动它来消除该问题。在 Stack Overflow 上有这样做的例子。

System.Timers.Timer 是 System.Threading.Timer 的组件包装器。它“针对高性能线程进行了优化”之类的想法很愚蠢。 System.Timers.Timer 为您提供了一个熟悉的面向事件的接口(interface)，还提供了一个 SynchronizingObject，它让您可以在特定线程上引发事件，而不必显式地Invoke 就像使用 System.Threading.Timer 一样。通常，这仅在 UI 应用程序中有用。

System.Timers.Timer 有一个我认为是错误的特别丑陋的“功能”:它会压缩异常。作为the documentation说:

In the .NET Framework version 2.0 and earlier, the Timer component catches and suppresses all exceptions thrown by event handlers for the Elapsed event.

该行为在 .NET 4.5 中仍然存在。问题是，如果您有 Elapsed 事件:

private static void OnTimedEvent(object source, ElapsedEventArgs e)
{
    // do stuff here
}

如果您的事件处理程序抛出异常，它将传播回计时器代码，计时器代码会压缩异常并且永远不会告诉您。实际上，定时器是这样做的:

try
{
    OnTimedEvent(source, args);
}
catch
{
    // Squash those pesky exceptions. Who needs them?
}

它是一个错误隐藏器，因为您永远不知道异常已被抛出。所以你的程序不工作，你不知道为什么。出于这个原因，我强烈建议您不要使用 System.Timers.Timer。使用 System.Threading.Timer 代替；毕竟，它是构建 System.Timers.Timer 的基础。