2

在下面的代码中TimerRecalcStatisticsElapsed应该只运行一个实例。此回调调用的工作方法按顺序运行，一次最多运行一个线程。

问题第 1 部分：

如果计时器的回调运行一个线程池线程（而不是在单独的线程上运行回调），那么说线程池可能会排队并推迟线程以供以后执行基于条件（达到 MaxThreads，线程池内部逻辑）是否正确?

问题第 2 部分：

假设一个计时器回调可以排队等待除立即执行之外的任何事情，这是否意味着任意数量的线程回调可以同时执行？

问题第 3 部分

假设第 2 部分为真，这是否意味着下面的代码可以同时运行多个回调？

我问的原因是因为有数千个此类的实例在多 CPU 服务器上运行。我还看到数据损坏与// Do Work Here.

在旁边

// Do work here在内部使用 System.Collections.Dictionary 并编辑 y 的值。它还为串行调用的后续函数删除了一些键。该函数缺少以前在第一次调用中存在的键 (x)。我认为这是因为最终陈述存在竞争条件obj.cleanupdata() 

public class SystemTimerTest
   {

    readonly System.Timers.Timer timerRecalcStatistics;
    readonly System.Diagnostics.Stopwatch stopwatchForRecalcStatistics = new System.Diagnostics.Stopwatch();


    public SystemTimerTest(TimeSpan range, DataOverwriteAction action)
    {
        int recalculateStatisticsEveryXMillseconds = 1000;

        timerRecalcStatistics = new System.Timers.Timer(recalculateStatisticsEveryXMillseconds);
        timerRecalcStatistics.AutoReset = true;
        timerRecalcStatistics.Elapsed += new System.Timers.ElapsedEventHandler(TimerRecalcStatisticsElapsed);
        timerRecalcStatistics.Interval = recalculateStatisticsEveryXMillseconds;
        timerRecalcStatistics.Enabled = true;


        this.maxRange = range;
        this.hashRunningTotalDB = new HashRunningTotalDB(action);
        this.hashesByDate = new HashesByDate(action);
        this.dataOverwriteAction = action;
    }


    private void TimerRecalcStatisticsElapsed(object source, System.Timers.ElapsedEventArgs e)
    {
        stopwatchForRecalcStatistics.Start();
        Console.WriteLine("The TimerRecalcStatisticsElapsed event was raised at {0}", e.SignalTime.ToString("o"));

         // DO WORK HERE


        stopwatchForRecalcStatistics.Stop();
        double timeBuffer  = GetInterval(IntervalTypeEnum.NearestSecond, e.SignalTime) - stopwatchForRecalcStatistics.ElapsedMilliseconds;

        if (timeBuffer > 0)
            timerRecalcStatistics.Interval = timeBuffer;
        else
            timerRecalcStatistics.Interval = 1;

        stopwatchForRecalcStatistics.Reset();         
        timerRecalcStatistics.Enabled = true;
    }
 }
4

2 回答 2

4

ad 1) ThreadPool 是否可以推迟回调方法的执行并不重要，因为无论如何回调不能保证在另一个计时器间隔过去之前完成执行（例如，线程可以被线程调度程序挂起，或者回调可能会调用 long-运行功能）。

广告 2）这是 MSDN 关于Timer类的说法：

如果 SynchronizingObject 属性为 null，则在 ThreadPool 线程上引发 Elapsed 事件。如果 Elapsed 事件的处理持续时间超过 Interval，则该事件可能会在另一个 ThreadPool 线程上再次引发。在这种情况下，事件处理程序应该是可重入的。

所以答案是肯定的，回调可以同时在多个线程上执行。

广告 3) 是的。并且您应该避免在回调方法中使用共享资源（timerRecalcStatistics、stopwatchForRecalcStatistics），或者同步对这些共享资源的访问（例如使用锁），或者将适当的对象设置为 Timer 的SynchronizingObject属性，或者将 Timer 的 AutoReset 属性设置为 false（并且在计时器回调结束时再次启用计时器）。

更新：我认为 Jon Skeet 的回答并不能解决您的问题。同样实现你自己的SynchonizingObject 恕我直言，比必要的更复杂（但如果不知道整个问题就很难说）。我希望这个实现应该可以工作（但我没有测试过）：

public class MySynchronizeInvoke : ISynchronizeInvoke
{
    private object SyncObject = new Object();
    private delegate object InvokeDelegate(Delegate method, object[] args);

    public IAsyncResult BeginInvoke(Delegate method, object[] args)
    {
        ElapsedEventHandler handler = (ElapsedEventHandler)method;
        InvokeDelegate D = Invoke;
        return D.BeginInvoke(handler, args, CallbackMethod, null);
    }

    private void CallbackMethod(IAsyncResult ar)
    {
        AsyncResult result = ar as AsyncResult;
        if(result != null)
            ((InvokeDelegate)result.AsyncDelegate).EndInvoke(ar);
    }

    public object EndInvoke(IAsyncResult result)
    {
        result.AsyncWaitHandle.WaitOne();
        return null;
    }

    public object Invoke(Delegate method, object[] args)
    {
        lock(SyncObject)
        {
            ElapsedEventHandler handler = (ElapsedEventHandler)method;
            handler(args[0], (ElapsedEventArgs)args[1]);
            return null;
        }
    }

    public bool InvokeRequired
    {
        get { return true; }
    }
}
于 2012-05-18T14:49:08.060 回答
3

从System.Timers.Timer 的文档中：

如果 SynchronizingObject 属性为 null，则在 ThreadPool 线程上引发 Elapsed 事件。如果 Elapsed 事件的处理持续时间超过 Interval，则该事件可能会在另一个 ThreadPool 线程上再次引发。在这种情况下，事件处理程序应该是可重入的。

所以回答你的问题：

  1. 是的，它在线程池线程上运行，并且像其他任何东西一样受到线程池填充和延迟的影响。鉴于线程池现在最多有数百个线程，这应该不是问题。如果是这样，你有更大的问题。

  2. 假设您没有设置同步对象或以其他方式同步您的回调，是的，多个回调可以重叠。如果你给定时器一个同步对象，它就不会“重叠”事件。

  3. 您提供的代码不会以任何方式同步它的回调，所以是的，它可以有多个重叠，同时执行回调的副本。如果您希望类的所有实例彼此同步，您应该使用类似 lock 语句的方法来同步方法，或者如果您希望类的每个单独实例只运行一个回调，则使用计时器的 SynchronizingObject在任何给定时间。

于 2012-05-18T14:45:39.853 回答