Solution to Timer timer reentrancy problem in C#

The timer is used in the project to perform scheduled tasks as the service starts, and perform related operations at the specified punctual time. However, I only want it to be executed once within the specified punctual time to avoid reentrancy problems.

First, let’s briefly introduce timer. The timer mentioned here refers to System.Timers.timer. As the name suggests, it can trigger events at specified intervals. The official introduction is here, and the excerpt is as follows:

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

So what are the benefits of using this timer? Mainly because it is implemented through .NET Thread Pool, is lightweight, has accurate timing, and has no special requirements for applications and messages.

How to use Timer I have written this article before: The use of C# System.Timers.Timer timer and the application of automatic cleaning of memory at regular intervals

What is reentrancy? This is a concept about multi-threaded programming: in a program, when multiple threads run at the same time, the same method may be called by multiple processes at the same time. When there is some non-thread-safe code in this method, method reentrancy will lead to data inconsistency. Timer method reentrancy refers to the use of multi-threaded timers. Before the processing of one Timer is completed, when the time is up, the other Timer will continue to enter the method for processing.

Regarding the solution to the reentrancy problem of the timer, try the following :

1. Use the lock(Object) method to prevent reentrancy, indicating that a Timer is being processed Execution, when the next Timer occurs, it is found that the previous one has not been executed, so waits for execution, which is suitable for scenarios where reentrancy rarely occurs. Add lock to the triggering method, so that when thread 2 enters the triggering method and finds that it has been locked, it will wait for the code in the lock to be processed before executing. The code is as follows:

private static System.Timers.Timer aTimer = new System.Timers.Timer();
 private static object loker=new object();
   /// <summary>
        /// 设置定时器
        /// </summary>
        public static void SetTimer()
        {
            //读取配置时间
            try
            {
                aTimer.Interval = 30000;
                aTimer.Elapsed += new System.Timers.ElapsedEventHandler(OnTimedEvent);
                aTimer.AutoReset = true;//每到指定时间Elapsed事件是到时间就触发
                aTimer.Enabled = true; //指示 Timer 是否应引发 Elapsed 事件。
            }
            catch (Exception ex)
            {
                LogManager.RecordLog(LogType.Error, "ipad数据同步出错：" +ex.Message,ex);
            }
        }
        private static void OnTimedEvent(Object source, ElapsedEventArgs e)
        {
            //如果当前时间是为配置的准点时间就进来
            var time =Convert.ToInt32( SynchronousHelper.AppConfig.get_Items("SycTime"));
            if (DateTime.Now.Hour == time && DateTime.Now.Minute == 0)
            {
                //lock，这样当线程2进入触发的方法中，发现已经被锁，会等待锁中的代码处理完在执行
                lock (loker)
                {
                    LogManager.RecordLog(LogType.Info, "数据开始同步时间：" + e.SignalTime, null);
                    SetTimerStart();
                    System.Threading.Thread.Sleep(60000); //执行完越过当前分钟，使整点内只能进来一次
                }
            }
        }

2. Set a flag, Indicates that a Timer processing is being executed. When the next Timer occurs, it is found that the previous one has not been executed and gives up (note that this is giving up, not waiting. You will understand what it means by looking at the execution results). Suitable for scenarios where re-entry occurs frequently. Assigning values ​​to inTimer is not safe enough under multi-threading. Interlocked.Exchange provides a lightweight thread-safe method of assigning values ​​to objects (it feels more advanced and is also a more recommended method).

private static System.Timers.Timer aTimer = new System.Timers.Timer();
 private static int inTimer = 0;

        /// <summary>
        /// 设置定时器
        /// </summary>
        public static void SetTimer()
        {
            //读取配置时间
            try
            {
                aTimer.Interval = 30000; //半分钟触发一次
                aTimer.Elapsed += new System.Timers.ElapsedEventHandler(OnTimedEvent);
                aTimer.AutoReset = true;//每到指定时间Elapsed事件是到时间就触发
                aTimer.Enabled = true; //指示 Timer 是否应引发 Elapsed 事件。
            }
            catch (Exception ex)
            {
                LogManager.RecordLog(LogType.Error, "ipad数据同步出错：" +ex.Message,ex);
            }
        }
        private static void OnTimedEvent(Object source, ElapsedEventArgs e)
        {
            //如果当前时间是为配置的准点时间就进来
            var time =Convert.ToInt32( SynchronousHelper.AppConfig.get_Items("SycTime"));
            if (DateTime.Now.Hour == time && DateTime.Now.Minute == 0)
            {
                //inTimer设置一个标志，表示一个Timer处理正在执行，下一个Timer发生的时候发现上一个没有执行完就放弃
                if (Interlocked.Exchange(ref inTimer, 1) == 0)
                {
                    LogManager.RecordLog(LogType.Info, "数据开始同步时间：" + e.SignalTime, null);
                    SetTimerStart();
                    System.Threading.Thread.Sleep(60000); //执行完等待越过当前分钟，使整点内只能进来一次
                    Interlocked.Exchange(ref inTimer, 0);
                }
            }
        }

To summarize, timer is a very simple class that can be used immediately. Here we mainly summarize the solution to the reentrancy problem when using timer. I have never thought about this problem before, and the solution is quite good. Simple. The solution here also applies to multi-threaded reentrancy issues.

The above is the detailed content of Solution to Timer timer reentrancy problem in C#. For more information, please follow other related articles on the PHP Chinese website!