最近用Timer踩了一個坑，分享一下避免別人繼續踩

 

　　最近做一個小專案，專案中有一個定時服務，需要向對方定時傳送資料，時間間隔是1.5s，然後就想到了用C#的Timer類，我們知道Timer

確實非常好用，因為裡面有非常人性化的start和stop功能，在Timer裡面還有一個Interval，就是用來設定時間間隔，然後時間間隔到了就會觸

發Elapsed事件，我們只需要把callback函式註冊到這個事件就可以了，如果Interval到了就會觸發Elapsed，貌似一切看起來很順其自然，但是

有一點一定要注意，callback函式本身執行也是需要時間的，也許這個時間是1s，2s或者更長時間，而timer類卻不管這些，它只顧1.5s觸發一下

Elapsed，這就導致了我的callback可能還沒有執行完，下一個callback又開始執行了，也就導致了沒有達到我預期的1.5s的效果，並且還出現了

一個非常嚴重的問題，那就是執行緒激增，非常恐怖。

 

   下面舉個例子，為了簡化一下，我就定義一個task任務，當然專案中是多個task任務一起跑的。

 

一：問題產生

   為了具有更高的靈活性，我定義了一個CustomTimer類繼承自Timer，然後裡面可以放些Task要跑的資料，這裡就定義一個Queue。

namespace Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            TimerCustom timer = new TimerCustom();

            timer.Interval = 1500;

            timer.Elapsed += (obj, evt) =>
            {
                TimerCustom singleTimer = obj as TimerCustom;

                if (singleTimer != null)
                {
                    if (singleTimer.queue.Count != 0)
                    {
                        var item = singleTimer.queue.Dequeue();

                        Send(item);
                    }
                }
            };

            timer.Start();

            Console.Read();
        }

        static void Send(int obj)
        {
            //隨機暫定8-10s
            Thread.Sleep(new Random().Next(8000, 10000));

            Console.WriteLine("當前時間：{0}，定時資料傳送成功！", DateTime.Now);
        }
    }

    class TimerCustom : System.Timers.Timer
    {
        public Queue<int> queue = new Queue<int>();

        public TimerCustom()
        {
            for (int i = 0; i < short.MaxValue; i++)
            {
                queue.Enqueue(i);
            }
        }
    }
}

 

二：解決方法

1.  從上圖看，在一個任務的情況下就已經有14個執行緒了，並且在21s的時候有兩個執行緒同時執行了，我的第一反應就是想怎麼把後續執行callback的

執行緒踢出去，也就是保證當前僅讓兩個執行緒在用callback，一個在執行，一個在等待執行，如果第一個執行緒的callback沒有執行完，後續如果來了第三

個執行緒的話，我就把這第三個執行緒直接踢出去，直到第一個callback執行完後，才允許第三個執行緒進來並等待執行callback，然後曾今的第二個執行緒開

始執行callback，後續的就以此類推。。。

然後我就想到了用lock機制，在customTimer中增加lockMe，lockNum,isFirst欄位，用lockMe來鎖住，用lockNum來踢當前多餘的要執行callback

的執行緒,用isFirst來判斷是不是第一次執行該callback，後續callback的執行緒必須先等待1.5s再執行。

namespace Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            TimerCustom timer = new TimerCustom();

            timer.Interval = 1500;

            timer.Elapsed += (obj, evt) =>
            {
                TimerCustom singleTimer = obj as TimerCustom;

                if (singleTimer != null)
                {
                    //如果當前等待執行緒>2，就踢掉該執行緒
                    if (Interlocked.Read(ref singleTimer.lockNum) > 2)
                        return;

                    Interlocked.Increment(ref singleTimer.lockNum);

                    //這裡的lock只能存在一個執行緒等待
                    lock (singleTimer.lockMe)
                    {
                        if (!singleTimer.isFirst)
                        {
                            Thread.Sleep((int)singleTimer.Interval);
                        }

                        singleTimer.isFirst = false;

                        if (singleTimer.queue.Count != 0)
                        {
                            var item = singleTimer.queue.Dequeue();

                            Send(item);

                            Interlocked.Decrement(ref singleTimer.lockNum);
                        }
                    }
                }
            };

            timer.Start();

            Console.Read();
        }

        static void Send(int obj)
        {
            Thread.Sleep(new Random().Next(8000, 10000));

            Console.WriteLine("當前時間：{0}，郵件傳送成功！", DateTime.Now);
        }
    }

    class TimerCustom : System.Timers.Timer
    {
        public Queue<int> queue = new Queue<int>();

        public object lockMe = new object();

        public bool isFirst = true;

        /// <summary>
        /// 為保持連貫性，預設鎖住兩個
        /// </summary>
        public long lockNum = 0;

        public TimerCustom()
        {
            for (int i = 0; i < short.MaxValue; i++)
            {
                queue.Enqueue(i);
            }
        }
    }
}

 

 

從圖中可以看到，已經沒有同一秒出現重複任務的傳送情況了，並且執行緒也給壓制下去了，乍一看效果不是很明顯，不過這是在一個任務的情況

下的場景，任務越多就越明顯了，所以這個就達到我要的效果。

 

2. 從上面的解決方案來看，其實我們的思維已經被問題約束住了，當時我也是這樣，畢竟坑出來了，就必須來填坑，既然在callback中出現執行緒

　 蜂擁的情況，我當然要想辦法管制了，其實這也沒什麼錯，等問題解決了再回頭考慮下時，我們會發現文章開頭說的Timer類有強大的Stop和

   Start功能，所以。。。。這個時候思維就跳出來了，何不在callback執行的時候把Timer關掉，執行完callback後再把Timer開啟，這樣不就

   可以解決問題嗎？好吧，說幹就幹。

namespace Sample
{
    class Program
    {
        static void Main(string[] args)
        {
            TimerCustom timer = new TimerCustom();

            timer.Interval = 1500;

            timer.Elapsed += (obj, evt) =>
            {
                TimerCustom singleTimer = obj as TimerCustom;

                //先停掉
                singleTimer.Stop();

                if (singleTimer != null)
                {
                    if (singleTimer.queue.Count != 0)
                    {
                        var item = singleTimer.queue.Dequeue();

                        Send(item);

                        //傳送完成之後再開啟
                        singleTimer.Start();
                    }
                }
            };

            timer.Start();

            Console.Read();
        }

        static void Send(int obj)
        {
            Thread.Sleep(new Random().Next(8000, 10000));

            Console.WriteLine("當前時間：{0}，郵件傳送成功！", DateTime.Now);
        }
    }

    class TimerCustom : System.Timers.Timer
    {
        public Queue<int> queue = new Queue<int>();

        public object lockMe = new object();

        /// <summary>
        /// 為保持連貫性，預設鎖住兩個
        /// </summary>
        public long lockNum = 0;

        public TimerCustom()
        {
            for (int i = 0; i < short.MaxValue; i++)
            {
                queue.Enqueue(i);
            }
        }
    }
}

 

從圖中可以看到，問題同樣得到解決，而且更簡單，精妙。

最後總結一下：解決問題的思維很重要，但是如果跳出思維站到更高的抽象層次上考慮問題貌似也很難得。。。