C#中Timer使用及解决重入问题

★前言

打开久违的Live Writer,又已经好久没写博客了,真的太懒了。废话不多说了,直接进入这次博客的主题--Timer。为什么要写这个呢,因为前几天应朋友之邀,想做个“黑客”小工具,功能挺简单就是自动获取剪贴板的内容然后发送邮件,就需要用到Timer来循环获取剪贴板的内容,但是由于到了发送邮件这个功能,使用C#的SmtpClient始终发送不了邮件,以前写过类似发邮件的功能,当时可以用网易的,现在也不能用了,不知道咋回事,只好作罢。在使用Timer中遇到了之前没有想过的问题--重入。

★介绍

首先简单介绍一下timer,这里所说的timer是指的System.Timers.timer,顾名思义,就是可以在指定的间隔是引发事件。官方介绍在这里,摘抄如下:

Timer 组件是基于服务器的计时器,它使您能够指定在应用程序中引发 Elapsed 事件的周期性间隔。然后可通过处理这个事件来提供常规处理。 例如,假设您有一台关键性服务器,必须每周 7 天、每天 24 小时都保持运行。 可以创建一个使用 Timer 的服务,以定期检查服务器并确保系统开启并在运行。 如果系统不响应,则该服务可以尝试重新启动服务器或通知管理员。
    基于服务器的 Timer 是为在多线程环境中用于辅助线程而设计的。 服务器计时器可以在线程间移动来处理引发的 Elapsed 事件,这样就可以比 Windows 计时器更精确地按时引发事件。

如果想了解跟其他的timer有啥区别,可以看这里,里面有详细的介绍,不再多说了(其实我也不知道还有这么多)。那使用这个计时器有啥好处呢?主要因为它是通过.NET Thread Pool实现的、轻量、计时精确、对应用程序及消息没有特别的要求。

★使用

下面就简单介绍一下,这个Timer是怎么使用的,其实很简单,我就采用微软提供的示例来进行测试,直接上代码了:

   //Timer不要声明成局部变量,否则会被GC回收
    private static System.Timers.Timer aTimer;

    public static void Main()
    {
        //实例化Timer类,设置间隔时间为10000毫秒;
        aTimer = new System.Timers.Timer(10000);

        //注册计时器的事件
        aTimer.Elapsed += new ElapsedEventHandler(OnTimedEvent);

        //设置时间间隔为2秒(2000毫秒),覆盖构造函数设置的间隔
        aTimer.Interval = 2000;

        //设置是执行一次(false)还是一直执行(true),默认为true
        aTimer.AutoReset = true;

        //开始计时
        aTimer.Enabled = true;

        Console.WriteLine("按任意键退出程序。");
        Console.ReadLine();
    }

    //指定Timer触发的事件
    private static void OnTimedEvent(object source, ElapsedEventArgs e)
    {
        Console.WriteLine("触发的事件发生在: {0}", e.SignalTime);
    }

运行的结果如下,计时蛮准确的:

/*
按任意键退出程序。
触发的事件发生在: 2014/12/26 星期五 23:08:51
触发的事件发生在: 2014/12/26 星期五 23:08:53
触发的事件发生在: 2014/12/26 星期五 23:08:55
触发的事件发生在: 2014/12/26 星期五 23:08:57
触发的事件发生在: 2014/12/26 星期五 23:08:59
*/

★重入问题重现及分析

什么叫重入呢?这是一个有关多线程编程的概念:程序中,多个线程同时运行时,就可能发生同一个方法被多个进程同时调用的情况。当这个方法中存在一些非线程安全的代码时,方法重入会导致数据不一致的情况。Timer方法重入是指使用多线程计时器,一个Timer处理还没有完成,到了时间,另一Timer还会继续进入该方法进行处理。下面演示一下重入问题的产生(可能重现的不是很好,不过也能简单一下说明问题了):

    //用来造成线程同步问题的静态成员
    private static int outPut = 1;
    //次数,timer没调一次方法自增1
    private static int num = 0;

    private static System.Timers.Timer timer = new System.Timers.Timer();

    public static void Main()
    {
        timer.Interval = 1000;
        timer.Elapsed += TimersTimerHandler;
        timer.Start();

        Console.WriteLine("按任意键退出程序。");
        Console.ReadLine();
    }

    /// <summary>
    /// System.Timers.Timer的回调方法
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="args"></param>
    private static void TimersTimerHandler(object sender, EventArgs args)
    {
        int t = ++num;
        Console.WriteLine(string.Format("线程{0}输出:{1},       输出时间:{2}", t, outPut.ToString(),DateTime.Now));
        System.Threading.Thread.Sleep(2000);
        outPut++;
        Console.WriteLine(string.Format("线程{0}自增1后输出:{1},输出时间:{2}", t, outPut.ToString(),DateTime.Now));
    }

下面显示一下输出结果:

是不是感觉上面输出结果很奇怪,首先是线程1输出为1,没有问题,然后隔了2秒后线程1自增1后输出为2,这就有问题了,中间为什么还出现了线程2的输出?更奇怪的是线程2刚开始输出为1,自增1后尽然变成了3!其实这就是重入所导致的问题。别急,咱们分析一下就知道其中的缘由了。

首先timer启动计时后,开启一个线程1执行方法,当线程1第一次输出之后,这时线程1休眠了2秒,此时timer并没有闲着,因为设置的计时间隔为1秒,当在线程1休眠了1秒后,timer又开启了线程2执行方法,线程2才不管线程1是执行中还是休眠状态,所以此时线程2的输出也为1,因为线程1还在休眠状态,并没有自增。然后又隔了1秒,这时发生同时发生两个事件,线程1过了休眠状态自增输出为2,timer同时又开启一个线程3,线程3输出的为线程1自增后的值2,又过了1秒,线程2过了休眠状态,之前的输出已经是2,所以自增后输出为3,又过了1秒……我都快晕了,大概就是这意思吧,我想表达的就是:一个Timer开启的线程处理还没有完成,到了时间,另一Timer还会继续进入该方法进行处理。

那怎么解决这个问题呢?解决方案有三种,下面一一道来,适应不同的场景,不过还是推荐最后一种,比较安全。

★重入问题解决方案

1、使用lock(Object)的方法来防止重入,表示一个Timer处理正在执行,下一个Timer发生的时候发现上一个没有执行完就等待执行,适用重入很少出现的场景(具体也没研究过,可能比较占内存吧)。

代码跟上面差不多,在触发的方法中加入lock,这样当线程2进入触发的方法中,发现已经被锁,会等待锁中的代码处理完在执行,代码如下:

     private static object locko = new object();
     /// <summary>
     /// System.Timers.Timer的回调方法
     /// </summary>
    /// <param name="sender"></param>
    /// <param name="args"></param>
    private static void TimersTimerHandler(object sender, EventArgs args)
    {
        int t = ++num;         lock (locko)
        {
            Console.WriteLine(string.Format("线程{0}输出:{1},       输出时间:{2}", t, outPut.ToString(), DateTime.Now));
            System.Threading.Thread.Sleep(2000);
            outPut++;
            Console.WriteLine(string.Format("线程{0}自增1后输出:{1},输出时间:{2}", t, outPut.ToString(), DateTime.Now));
        }
    }

执行结果:

2、设置一个标志,表示一个Timer处理正在执行,下一个Timer发生的时候发现上一个没有执行完就放弃(注意这里是放弃,而不是等待哦,看看执行结果就明白啥意思了)执行,适用重入经常出现的场景。代码如下:

    private static int inTimer = 0;
    /// <summary>
    /// System.Timers.Timer的回调方法
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="args"></param>
    private static void TimersTimerHandler(object sender, EventArgs args)
    {
        int t = ++num;
        if (inTimer == 0)
        {
            inTimer = 1;
            Console.WriteLine(string.Format("线程{0}输出:{1},       输出时间:{2}", t, outPut.ToString(), DateTime.Now));
            System.Threading.Thread.Sleep(2000);
            outPut++;
            Console.WriteLine(string.Format("线程{0}自增1后输出:{1},输出时间:{2}", t, outPut.ToString(), DateTime.Now));
            inTimer = 0;
        }
    }

执行结果:

3、在多线程下给inTimer赋值不够安全,Interlocked.Exchange提供了一种轻量级的线程安全的给对象赋值的方法(感觉比较高上大,也是比较推荐的一种方法),执行结果与方法2一样,也是放弃执行。Interlocked.Exchange用法参考这里

    private static int inTimer = 0;
    /// <summary>
    /// System.Timers.Timer的回调方法
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="args"></param>
    private static void TimersTimerHandler(object sender, EventArgs args)
    {
        int t = ++num;
        if (Interlocked.Exchange(ref inTimer, 1) == 0)
        {
            Console.WriteLine(string.Format("线程{0}输出:{1},       输出时间:{2}", t, outPut.ToString(), DateTime.Now));
            System.Threading.Thread.Sleep(2000);
            outPut++;
            Console.WriteLine(string.Format("线程{0}自增1后输出:{1},输出时间:{2}", t, outPut.ToString(), DateTime.Now));
            Interlocked.Exchange(ref inTimer, 0);
        }
    }

执行结果:

★总结

终于码完字了,真心不容易啊。写博客是个挺耗精力的事情,真心佩服那些大牛们笔耕不辍,致敬!在这里稍微总结一下,timer是一个使用挺简单的类,拿来即用,这里主要总结了使用timer时重入问题的解决,以前也没思考过这个问题,解决方案也挺简单,在这里列出了三种,主要参考在这里,不知道还有没有其他的方式。这里的解决方案同时也适用多线程的重入问题。时间不早了,洗洗睡了。

★参考

在这里列出文章中没有提及的参考,感谢各位前辈们智慧的结晶!

ASP.NET----定时器回调方法的重入

时间: 2024-10-06 14:38:51

C#中Timer使用及解决重入问题的相关文章

重入锁----ReentrantLock

本节主要从下述四个方面介绍重入锁. 1.什么是重入锁? 2.为什么要引用重入锁? 3.重入锁是怎么实现的? 4.分析java并发包中ReentrantLock. 什么是重入锁 重入锁,支持重进入的锁,表示该锁能够支持一个线程对它重复加锁,即线程在获得锁之后再次获取该锁时不会被阻塞. 为什么要引用重入锁? 以子类重写父类方法为例: Mutix是不支持重入的锁.(代码摘抄自<java并发编程的艺术>) 1 import java.util.concurrent.TimeUnit; 2 import

可重入和线程安全简单介绍

可重入和线程安全 可重入和线程安全这两个术语,经常出现在计算机编程中,用于指明类和函数在多线程程序中的使用. 可重入:若一个程序或子程序可以“安全的被并行执行(Parallel computing)”,则称其为可重入(reentrant或re-entrant)的. 若一个函数是可重入的,则该函数: 1.不能含有静态(全局)非常量数据. 2.不能返回静态(全局)非常量数据的地址. 3.只能处理由调用者提供的数据. 4.不能依赖于单实例模式资源的锁. 5.不能调用(call)不可重入的函数. 线程安

C语言之可重入函数 &amp;&amp; 不可重入函数

可重入函数 在 实时系统的设计中,经常会出现多个任务调用同一个函数的情况.如果这个函数不幸被设计成为不可重入的函数的话,那么不同任务调用这个函数时可能修改其他任 务调用这个函数的数据,从而导致不可预料的后果.那么什么是可重入函数呢?所谓可重入是指一个可以被多个任务调用的过程,任务在调用时不必担心数据是否会 出错.不可重入函数在实时系统设计中被视为不安全函数. 满足下列条件的函数多数是不可重入的: (1)函数体内使用了静态的数据结构: (2)函数体内调用了malloc()或者free()函数: (

C语言可重入函数和不可重入函数

可重入函数 在 实时系统的设计中,经常会出现多个任务调用同一个函数的情况.如果这个函数不幸被设计成为不可重入的函数的话,那么不同任务调用这个函数时可能修改其他任 务调用这个函数的数据,从而导致不可预料的后果.那么什么是可重入函数呢?所谓可重入是指一个可以被多个任务调用的过程,任务在调用时不必担心数据是否会 出错.不可重入函数在实时系统设计中被视为不安全函数. 满足下列条件的函数多数是不可重入的: (1)函数体内使用了静态的数据结构: (2)函数体内调用了malloc()或者free()函数: (

关于C#中Timer定时器的重入问题解决方法

项目中用到了定时器随着服务启动作定时任务,按指定的准点时间定时执行相关操作,但是在指定准点时间内我只想让它执行一次,要避免重入问题的发生. 首先简单介绍一下timer,这里所说的timer是指的System.Timers.timer,顾名思义,就是可以在指定的间隔是引发事件.官方介绍在这里,摘抄如下: Timer 组件是基于服务器的计时器,它使您能够指定在应用程序中引发 Elapsed 事件的周期性间隔.然后可通过处理这个事件来提供常规处理. 例如,假设您有一台关键性服务器,必须每周 7 天.每

phpcms v9 中 PHPSSO无法通讯解决方法(PHPSSO无法通讯间接影响phpcms v9注册会员无法通过“重名无法通过”)

问题的由来 怎么样使用 Cocos2d-x 快速开发游戏,方法很简单,你可以看看其自带的例程,或者从网上搜索教程,运行起第一个HelloWorld,然后在 HelloWorld 里面写相关逻辑代码,添加我们的层.精灵等 ~ 我们并不一定需要知道 Cocos2d-x 是如何运行或者在各种平台之上运行,也不用知道 Cocos2d-x 的游戏是如何运行起来的,它又是如何渲染界面的 ~~~ 两个入口 程序入口的概念是相对的,AppDelegate 作为跨平台程序入口,在这之上做了另一层的封装,封装了不同

Signal处理中的函数可重入问题

1. Signal信号简介 信号是软件层次上模拟的中断,它是一种异步通信的处理机制.信号的异步性意味着,应用程序不用等待事件的发生,当信号发生时应用程序自动陷入到对应的信号处理函数中.产生信号的事件对进程而言是随机出现的.信号的响应方式有忽略.捕捉.执行默认动作三种. 2. 线程安全 线程安全函数:在C语言中局部变量是在栈中分配的,任何未使用静态数据或其他共享资源的函数都是线程安全的.使用全局变量的函数是非线程安全的.使用静态数据或其他共享资源的函数,必须通过加锁的方式来使函数实现线程安全. 线

Java 中15种锁的介绍:公平锁,可重入锁,独享锁,互斥锁,乐观锁,分段锁,自旋锁等等(转)

Java 中15种锁的介绍 在读很多并发文章中,会提及各种各样锁如公平锁,乐观锁等等,这篇文章介绍各种锁的分类.介绍的内容如下: 公平锁 / 非公平锁 可重入锁 / 不可重入锁 独享锁 / 共享锁 互斥锁 / 读写锁 乐观锁 / 悲观锁 分段锁 偏向锁 / 轻量级锁 / 重量级锁 自旋锁 上面是很多锁的名词,这些分类并不是全是指锁的状态,有的指锁的特性,有的指锁的设计,下面总结的内容是对每个锁的名词进行一定的解释. 公平锁 / 非公平锁 公平锁 公平锁是指多个线程按照申请锁的顺序来获取锁. 非公

浅谈Java中的锁:Synchronized、重入锁、读写锁

Java开发必须要掌握的知识点就包括如何使用锁在多线程的环境下控制对资源的访问限制 ◆ Synchronized ◆ 首先我们来看一段简单的代码: 12345678910111213141516171819 public class NotSyncDemo { public static int i=0; static class ThreadDemo extends Thread { @Override public void run() { for (int j=0;j<10000;j++)