c#计时器用法

Posted 2023-05-07

想测试一下c#的运行效率，当程序启动是开始计时，执行1万次for循环后停止计时，测试所需时间。
本来想通过获取系统时间相减来获取，但似乎不能精确到毫秒，所以求教下。

c#中提供了三种类型的计时器：
1、基于 Windows 的标准计时器(System.Windows.Forms.Timer)
2、基于服务器的计时器(System.Timers.Timer)
3、线程计时器(System.Threading.Timer)
下面我就通过一些小实验来具体分析三种计时器使用上面的异同点，特别是和线程有关的部分。
实验例子截图：

一、基于 Windows 的标准计时器(System.Windows.Forms.Timer)
首先注意一点就是：Windows 计时器是为单线程环境设计的
此计时器从Visual Basic 1.0 版起就存在于该产品中，并且基本上未做改动
这个计时器是使用最简单的一种，只要把工具箱中的Timer控件拖到窗体上，然后设置一下事件和间隔时间等属性就可以了

实验出来的结果也完全符合单线程的特点：
1、当启动此计时器后，会在下方子线程ID列表中显示子线程ID，并且和主线程ID相同
private void formsTimer_Tick(object sender, EventArgs e)

i++;
lblSubThread.Text += "子线程执行，线程ID：" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + "\\r\\n";


2、当单击主线程暂停5秒后，子线程会暂停执行，并且当5秒之后不会执行之前被暂停的子线程，而是直接执行后面的子线程(也就是会少输出几行值)
System.Threading.Thread.Sleep(5000);
3、在子进程的事件中暂停5秒会导致主窗口相应无响应5秒
4、定义一个线程静态变量：
[ThreadStatic]
private static int i = 0;
在子线程事件中每次加一，再点击线程静态变量值会得到增加后的i值

二、基于服务器的计时器(System.Timers.Timer)
System.Timers.Timer不依赖窗体，是从线程池唤醒线程，是传统的计时器为了在服务器环境上运行而优化后的更新版本
在VS2005的工具箱中没有提供现成的控件，需要手工编码使用此计时器
使用方式有两种，
1、通过SynchronizingObject属性依附于窗体

System.Timers.Timer timersTimer = new System.Timers.Timer();

timersTimer.Enabled = false;
timersTimer.Interval = 100;
timersTimer.Elapsed += new System.Timers.ElapsedEventHandler(timersTimer_Elapsed);

timersTimer.SynchronizingObject = this;

通过这种方式来使用，实验效果几乎和基于 Windows 的标准计时器一样，只是在上面的第二条实验中，虽然也会暂停子线程的执行，不过在5秒之后把之前排队的任务都执行掉(也就是不会少输出几行值)
2、不使用SynchronizingObject属性
这种方式就是多线程的方式了，即启动的子线程和主窗体不在一个线程。不过这样也存在一个问题：由于子线程是单独的一个线程，那么就不能访问住窗体中的控件了，只能通过代理的方式来访问：

delegate void SetTextCallback(string text);
.
.
void timersTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)

//使用代理
string text = "子线程执行，线程ID：" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + "\\r\\n";
SetTextCallback d = new SetTextCallback(SetText);
this.Invoke(d, new object[] text );
i++;


private void SetText(string text)

lblSubThread.Text += text;

这样我们再次实验就会得到如下的结果：
1、当启动此计时器后，会在下方子线程ID列表中显示子线程ID，并且和主线程ID不相同

2、当单击主线程暂停5秒后，子线程会一直往下执行(界面上可能看不出来，不过通过在子线程输出文件的方式可以很方便的看出来)
3、在子进程的事件中暂停5秒不会导致主窗口无响应
4、在子线程事件中每次给线程静态变量加一，再点击线程静态变量值得到的值还是0(不会改变主窗口中的线程静态变量)
三、线程计时器(System.Threading.Timer)
线程计时器也不依赖窗体，是一种简单的、轻量级计时器，它使用回调方法而不是使用事件，并由线程池线程提供支持。
对消息不在线程上发送的方案中，线程计时器是非常有用的。
使用方法如下：

System.Threading.Timer threadTimer;
public void ThreadMethod(Object state)

//使用代理
string text = "子线程执行，线程ID：" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString() + "\\r\\n";
SetTextCallback d = new SetTextCallback(SetText);
this.Invoke(d, new object[] text );
i++;


private void Form1_Load(object sender, EventArgs e)

threadTimer = new System.Threading.Timer(new System.Threading.TimerCallback(ThreadMethod), null, -1, -1);


暂停代码：
threadTimer.Change(-1, -1);

实验的效果和基于服务器的计时器(System.Timers.Timer)的第二种方式是一样的，
当然具体的使用方法和原理是不一样的，最主要的就是这种方式使用的是代理的方式而不是事件的方式，并且可以不依赖于窗体和组件而单独执行

下面列出老外总结的一张表(三种方式的区别)：
Feature descriptionSystem.Timers.TimerSystem.Threading.TimerSystem.Windows.Forms.Timer
Support for adding and removing listeners after the timer is instantiated.YesNoYes
Supports call backs on the user-interface threadYesNoYes
Calls back from threads obtained from the thread poolYesYesNo
Supports drag-and-drop in the Windows Forms DesignerYesNoYes
Suitable for running in a server multi-threaded environmentYesYesNo
Includes support for passing arbitrary state from the timer initialization to the callback.NoYesNo
Implements IDisposableYesYesYes
Supports one-off callbacks as well as periodic repeating callbacksYesYesYes
Accessible across application domain boundariesYesYesYes
Supports IComponent – hostable in an IContainerYesNoYes

原文来自网络 参考技术A 定时器精确度很低的，大约55ms，如果想精确计时，就在开始时获得一个时间，结束时获得一个时间，用DateTime.Now.Ticks获得时间，两个相减即可。追问

和楼下一样给个完整代码吧。
用DateTime.Now.Ticks获得时间的单位是什么？

追答// 开始计时
            long st = DateTime.Now.Ticks;
            // 写耗时代码吧
            // 结束计时，计算耗时
            long et = DateTime.Now.Ticks;
            long ct = et - st;
            TimeSpan ts = new TimeSpan(ct);
            MessageBox.Show(string.Format("总共消耗: 0毫秒", ts.TotalMilliseconds));

本回答被提问者采纳 参考技术B 用System.Windows.Forms.Timer
每1毫秒调用一次Timer的Tick事件来计时。
当你执行1万次for循环后调用Timer.Stop()停止计时器就行了 参考技术C using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Timers;
namespace RateDemo

class Program

static int countTime ;
static void Main(string[] args)

Timer time = new Timer();

bool flag = true;
time.Interval = 1;//设置timer时间间隔为1毫秒
time.Elapsed+=new ElapsedEventHandler(time_Elapsed);
for (int i = 0; i < 10000000; i++)

if (flag)

time.Start();
flag = false;

//时间和你在这里做的事情有关系

Console.WriteLine(countTime);
time.Stop();
Console.Read();

static void time_Elapsed(object sender, ElapsedEventArgs e)

countTime++;


追问

非常感谢！

C# 计时器是不是在单独的线程上运行？

【中文标题】C# 计时器是不是在单独的线程上运行？

【英文标题】：Do C# Timers elapse on a separate thread?C# 计时器是否在单独的线程上运行？

【发布时间】：2010-11-28 23:36:15

【问题描述】：

System.Timers.Timer 是否在与创建它的线程不同的线程上运行？

假设我有一个带有每 5 秒触发一次的计时器的课程。当计时器触发时，在 elapsed 方法中，一些对象被修改。假设修改这个对象需要很长时间，比如 10 秒。在这种情况下我会遇到线程冲突吗？

【问题讨论】：

这可能会导致问题。请注意，一般来说，线程池线程不是为长时间运行的进程设计的。

我遇到了这个问题，正在使用 Windows 服务进行测试。对我有用的是禁用计时器作为 OnTimer 事件中的第一条指令，执行我的任务，然后在最后启用计时器。这已经在生产环境中可靠地运行了一段时间。

我很惊讶 Monitor.TryEnter 在这里没有被提及作为一种方法。对我来说似乎比大多数其他方法更整洁，例如停止计时器。 if (Monitor.TryEnter(someObkect) ..do timer workload.. finally monitor.exit() 您还可以使用 else 子句记录定时事件被跳过，也可以添加逻辑来更新计时器频率.

【参考方案1】：

这取决于。 System.Timers.Timer 有两种操作模式。

如果SynchronizingObject 设置为ISynchronizeInvoke 实例，则Elapsed 事件将在托管同步对象的线程上执行。通常这些ISynchronizeInvoke 实例只不过是我们都熟悉的普通旧Control 和Form 实例。所以在这种情况下，Elapsed 事件在 UI 线程上被调用，它的行为类似于System.Windows.Forms.Timer。否则，它实际上取决于所使用的特定 ISynchronizeInvoke 实例。

如果SynchronizingObject 为空，则在ThreadPool 线程上调用Elapsed 事件，它的行为类似于System.Threading.Timer。事实上，它实际上在幕后使用了System.Threading.Timer，并在之后根据需要接收定时器回调来执行封送操作。

【讨论】：

如果您希望计时器回调在新线程上执行，您应该使用System.Threading.Timer 还是System.Timers.Timer？

@cj7: 任何一个都可以做到。

如果我有一个复杂类型（人）的列表并且想在每个人里面有时间？我需要在同一个线程（所有人）上运行它，因为如果它调用第一个人方法，第二个人必须等到第一个结束经过的事件。我可以这样做吗？

Everyone...System.Timers.Timer 有两种操作模式。它可以在随机分配的线程池线程上运行，也可以在托管ISynchronizeInvoke 实例的任何线程上运行。我不知道如何更清楚地说明这一点。 System.Threading.Timer 与原始问题几乎没有关系（如果有的话）。

@LeandroDeMelloFagundes 你不能用 lock 做那个吗？

【参考方案2】：

对于System.Timers.Timer：

见Brian Gideon's answer below

对于System.Threading.Timer：

MSDN Documentation on Timers 状态：

System.Threading.Timer 类使 ThreadPool 线程上的回调 和 根本不使用事件模型。

所以确实计时器在不同的线程上运行。

【讨论】：

没错，但那是一个完全不同的类别。 OP 询问了 System.Timers.Timer 类。

哦，你是对的。 msdn.microsoft.com/en-us/library/system.timers.timer.aspx 说“在 ThreadPool 线程上引发了 Elapsed 事件。”我想从那里得出同样的结论。

嗯，是的，但并不是那么简单。看我的回答。

【参考方案3】：

除非之前的 Elapsed 仍在运行，否则每个 elapsed 事件都将在同一个线程中触发。

所以它会为你处理碰撞

尝试将其放入控制台

static void Main(string[] args)

    Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);
    var timer = new Timer(1000);
    timer.Elapsed += timer_Elapsed;
    timer.Start();
    Console.ReadLine();


static void timer_Elapsed(object sender, ElapsedEventArgs e)

    Thread.Sleep(2000);
    Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);

你会得到这样的东西

10
6
12
6
12

其中 10 是调用线程，而 6 和 12 是从 bg elapsed 事件触发的。 如果您删除 Thread.Sleep(2000);你会得到这样的东西

10
6
6
6
6

因为没有碰撞。

但这仍然给你留下了一个问题。如果您每 5 秒触发一次事件并且需要 10 秒进行编辑，则您需要锁定以跳过某些编辑。

【讨论】：

在 Elapsed 事件方法的开头添加一个timer.Stop()，然后在 Elapsed 事件方法的末尾添加一个 timer.Start() 将防止 Elapsed 事件发生冲突。

你不需要放 timer.Stop() 你只需要定义 timer.AutoReset = false;然后在处理事件后制作 timer.Start() 。我认为这是避免碰撞的更好方法。

如果 Monitor.TryEnter

【参考方案4】：

对于 System.Timers.Timer，如果 SynchronizingObject 未设置，则在单独的线程上。

    static System.Timers.Timer DummyTimer = null;

    static void Main(string[] args)
    
        try
        

            Console.WriteLine("Main Thread Id: " + System.Threading.Thread.CurrentThread.ManagedThreadId);

            DummyTimer = new System.Timers.Timer(1000 * 5); // 5 sec interval
            DummyTimer.Enabled = true;
            DummyTimer.Elapsed += new System.Timers.ElapsedEventHandler(OnDummyTimerFired);
            DummyTimer.AutoReset = true;

            DummyTimer.Start();

            Console.WriteLine("Hit any key to exit");
            Console.ReadLine();
        
        catch (Exception Ex)
        
            Console.WriteLine(Ex.Message);
        

        return;
    

    static void OnDummyTimerFired(object Sender, System.Timers.ElapsedEventArgs e)
    
        Console.WriteLine(System.Threading.Thread.CurrentThread.ManagedThreadId);
        return;
    

输出你会看到 DummyTimer 是否以 5 秒的间隔触发：

Main Thread Id: 9
   12
   12
   12
   12
   12
   ... 

所以，正如所见，OnDummyTimerFired 是在 Workers 线程上执行的。

不，更复杂 - 如果您将间隔缩短到 10 毫秒，

Main Thread Id: 9
   11
   13
   12
   22
   17
   ... 

这是因为如果 OnDummyTimerFired 的 prev 执行在下一个 tick 被触发时没有完成，那么 .NET 将创建一个新线程来完成这项工作。

更复杂的是，“System.Timers.Timer 类提供了一种简单的方法来解决这个难题——它公开了一个公共 SynchronizingObject 属性。将此属性设置为 Windows 窗体的实例（或Windows 窗体）将确保 Elapsed 事件处理程序中的代码在实例化 SynchronizingObject 的同一线程上运行。"

http://msdn.microsoft.com/en-us/magazine/cc164015.aspx#S2

【讨论】：

这是一个很好的例子。直到现在我才知道，我需要在这里和那里设置一些锁。完美。

如果我想让计时器在控制台应用程序的主线程中触发 Elapsed 事件怎么办？

【参考方案5】：

如果经过的事件比间隔时间长，它将创建另一个线程来引发经过的事件。但是有一个解决方法

static void timer_Elapsed(object sender, ElapsedEventArgs e)    
     
   try
   
      timer.Stop(); 
      Thread.Sleep(2000);        
      Debug.WriteLine(Thread.CurrentThread.ManagedThreadId);    
   
   finally
   
     timer.Start();
   

【讨论】：

+1 简单而干净的答案，但这并不总是有效。而是应该使用计时器的锁定或 SynchronizingObject 属性。

你在这里至少有一个理论上的竞争条件，当计时器在Stop被击中之前再次过去时就会发生这种情况。虽然不太可能在更大的时间段内，但仍然不干净。使用将Autoreset 设置为false 的计时器，然后在事件发生时自动禁用计时器。你不需要打电话给Stop。