Question

那么您认为防止C＃Windows服务的多个线程同时运行的最佳方法是什么（该服务使用timer OnElapsed事件？

使用lock()或mutex？

我似乎无法理解mutex的概念，但使用lock()似乎对我的情况很好。

我是否应该花时间学习如何使用mutex？

Answer 1

使您的计时器一次性完成，并在已用事件处理程序中重新初始化它。例如，如果您使用的是System.Timers.Timer，则会将其初始化为：

myTimer.Elapsed = timer1Elapsed;
myTimer.Interval = 1000; // every second
myTimer.AutoReset = false; // makes it fire only once
myTimer.Enabled = true;

你过去的事件处理程序：

void timerElapsed(object source, ElapsedEventArgs e)
{
    // do whatever needs to be done
    myTimer.Start(); // re-enables the timer
}

这样做的缺点是计时器不会在一秒间隔内发射。相反，它会在最后一次滴答处理完成后触发一秒钟。

Answer 2

不要使用计时器来生成线程。只开始一个线程。当线程完成一个工作循环时，计算下一个循环开始之前剩余的时间。如果此间隔为0或负数，则立即循环并开始新的循环，如果为正，则在循环之前休眠该间隔。

这通常通过在完成标记和开始标记之间取无符号int减法的int结果来完成，因此给出工作所用的经过的标记。从期望的时间间隔中减去这个时间会给出新的剩余时间。

不需要额外的计时器线程，不可能同时运行两个线程，简化整体设计，不连续创建/启动/终止/销毁，没有mallocs，没有new（），没有堆栈分配/解除分配，没有GC。

使用定时器，互斥锁，信号量，锁等的其他设计过于复杂。如果只是更容易和更简单地不做任何额外的线程，为什么还要尝试使用同步停止额外的线程呢？

有时，使用计时器而不是sleep（）循环只是一个非常糟糕的主意。这听起来像是其中一次。

public void doWorkEvery(int interval)
{
    while (true)
    {
        uint startTicks;
        int workTicks, remainingTicks;
        startTicks = (uint)Environment.TickCount;
        DoSomeWork();
        workTicks=(int)((uint)Environment.TickCount-startTicks);
        remainingTicks = interval - workTicks;
        if (remainingTicks>0) Thread.Sleep(remainingTicks);
    }
}

Answer 3

Instead of lock you can use Monitor.TryEnter() to return if a callback is already being executed by another timer thread:

class Program
{
    static void Main(string[] args)
    {
        Timer t = new Timer(TimerCallback, null,0,2000);
        Console.ReadKey();
    }

    static object timerLock = new object();

    static void TimerCallback(object state)
    {
        int tid = Thread.CurrentThread.ManagedThreadId;
        bool lockTaken = false;
        try
        {
            lockTaken = Monitor.TryEnter(timerLock);
            if (lockTaken)
            {
                Console.WriteLine("[{0:D02}]: Task started", tid);
                Thread.Sleep(3000); // Do the work 
                Console.WriteLine("[{0:D02}]: Task finished", tid);
            }
            else
            {
                Console.WriteLine("[{0:D02}]: Task is already running", tid);
            }
        }
        finally
        {
            if (lockTaken) Monitor.Exit(timerLock);
        }
    }
}

Answer 4

如果你想要的是阻止同一进程/ app域中的两个线程同时执行，那么lock语句可能会为你做。

但是请注意lock在等待访问关键部分时，其他线程，已锁定。它们不会被中止或重定向或任何东西;他们坐在那里，等待原始线程完成lock块的执行，以便它们可以运行。

mutex会让你获得更大的控制权;包括让第二个和后续线程完全停止，而不是锁定和跨进程锁定线程的能力。

Answer 5

我想我知道你在做什么。你有一个定时执行回调的定时器（定时器的定义），并且回调做了一些工作。这项工作实际上可能比定时器周期花费更多的时间（例如，定时器周期为500毫秒，并且给定的回调调用可能需要更长的时间500毫秒）。这意味着您的回调需要重新进入。

如果你不能重入（并且有多种原因可能会这样）;我过去所做的是在回调开始时关闭计时器，然后在结束时重新打开它。例如：

private void timer_Elapsed(object source, ElapsedEventArgs e)
{
    timer.Enabled = false;
    //... do work
    timer.Enabled = true;
}

如果你想让一个“线程”一个接一个地执行，我不会建议使用一个计时器;我建议使用Task对象。例如

Task.Factory.StartNew(()=>{
    // do some work
})
.ContinueWith(t=>{
    // do some more work without running at the same time as the previous
});

Answer 6

我认为其中一些方法很棒，但有点复杂。

我创建了一个包装器类来防止计时器重叠，并允许您选择“每个INTERVAL应该调用”ELAPSED“还是”调用之间应该发生INTERVAL延迟“。

如果您改进此代码，请在此处发布更新！

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace AllCommander.Diagnostics {
    public class SafeTimer : IDisposable {

        public enum IntervalStartTime {
            ElapsedStart,
            ElapsedFinish
        }


        private System.Timers.Timer InternalTimer;

        public bool AutoReset { get; set; }

        public bool Enabled {
            get {
                return InternalTimer.Enabled;
            }
            set {
                if (value) {
                    Start();
                } else {
                    Stop();
                }
            }
        }


        private double __Interval;
        public double Interval {
            get {
                return __Interval;
            }
            set {
                __Interval = value;
                InternalTimer.Interval = value;
            }
        }

        /// <summary>
        /// Does the internal start ticking at the END of Elapsed or at the Beginning? 
        /// </summary>
        public IntervalStartTime IntervalStartsAt { get; set; }

        public event System.Timers.ElapsedEventHandler Elapsed;


        public SafeTimer() {
            InternalTimer = new System.Timers.Timer();
            InternalTimer.AutoReset = false;
            InternalTimer.Elapsed += InternalTimer_Elapsed;

            AutoReset = true;
            Enabled = false;
            Interval = 1000;
            IntervalStartsAt = IntervalStartTime.ElapsedStart;
        }


        void InternalTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) {

            if (Elapsed != null) {
                Elapsed(sender, e);
            }

            var ElapsedTime = DateTime.Now - e.SignalTime;


            if (AutoReset == true) {
                //Our default interval will be INTERVAL ms after Elapsed finished.
                var NewInterval = Interval;
                if (IntervalStartsAt == IntervalStartTime.ElapsedStart) {
                    //If ElapsedStart is set to TRUE, do some fancy math to determine the new interval.
                    //If Interval - Elapsed is Positive, then that amount of time is remaining for the interval
                    //If it is zero or negative, we're behind schedule and should start immediately.
                    NewInterval = Math.Max(1, Interval - ElapsedTime.TotalMilliseconds);
                }

                InternalTimer.Interval = NewInterval;

                InternalTimer.Start();
            }

        }


        public void Start() {
            Start(true);
        }
        public void Start(bool Immediately) {
            var TimerInterval = (Immediately ? 1 : Interval);
            InternalTimer.Interval = TimerInterval;
            InternalTimer.Start();
        }

        public void Stop() {
            InternalTimer.Stop();
        }


        #region Dispose Code
        //Copied from https://lostechies.com/chrispatterson/2012/11/29/idisposable-done-right/
        bool _disposed;
        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        ~SafeTimer() {
            Dispose(false);
        }

        protected virtual void Dispose(bool disposing) {
            if (!_disposed) {
                if (disposing) {
                    InternalTimer.Dispose();
                }

                // release any unmanaged objects
                // set the object references to null
                _disposed = true;
            }
        }
        #endregion

    }
}

防止多个服务实例 - 最好的方法？

6 个答案: