使用英语阅读

通过

Timer.Stop 方法

  • 参考

定义

命名空间:
System.Timers
程序集:
netstandard.dll, System.ComponentModel.TypeConverter.dll
程序集:
System.ComponentModel.TypeConverter.dll
程序集:
System.dll
程序集:
netstandard.dll
Source:
Timer.cs
Source:
Timer.cs
Source:
Timer.cs

通过将 Enabled 设置为 false 停止引发 Elapsed 事件。

public void Stop();

示例

以下示例实例化一个 System.Timers.Timer 对象，该 Timer.Elapsed 对象每两秒 (2，000 毫秒) 触发一次事件，为事件设置事件处理程序，并启动计时器。 事件处理程序会在每次引发属性时显示该属性的值 ElapsedEventArgs.SignalTime 。 当用户按 Enter 键时，应用程序会在终止应用程序之前调用 Stop 方法。

using System;
using System.Timers;

public class Example
{
   private static System.Timers.Timer aTimer;
   
   public static void Main()
   {
      SetTimer();

      Console.WriteLine("\nPress the Enter key to exit the application...\n");
      Console.WriteLine("The application started at {0:HH:mm:ss.fff}", DateTime.Now);
      Console.ReadLine();
      aTimer.Stop();
      aTimer.Dispose();
      
      Console.WriteLine("Terminating the application...");
   }

   private static void SetTimer()
   {
        // Create a timer with a two second interval.
        aTimer = new System.Timers.Timer(2000);
        // Hook up the Elapsed event for the timer. 
        aTimer.Elapsed += OnTimedEvent;
        aTimer.AutoReset = true;
        aTimer.Enabled = true;
    }

    private static void OnTimedEvent(Object source, ElapsedEventArgs e)
    {
        Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",
                          e.SignalTime);
    }
}
// The example displays output like the following:
//       Press the Enter key to exit the application...
//
//       The application started at 09:40:29.068
//       The Elapsed event was raised at 09:40:31.084
//       The Elapsed event was raised at 09:40:33.100
//       The Elapsed event was raised at 09:40:35.100
//       The Elapsed event was raised at 09:40:37.116
//       The Elapsed event was raised at 09:40:39.116
//       The Elapsed event was raised at 09:40:41.117
//       The Elapsed event was raised at 09:40:43.132
//       The Elapsed event was raised at 09:40:45.133
//       The Elapsed event was raised at 09:40:47.148
//
//       Terminating the application...

下面的代码示例演示了一种防止调用 Stop 方法的线程在当前正在执行的事件结束之前继续执行 Elapsed 的方法，以及防止两 Elapsed 个事件同时执行事件处理程序的方法， (通常称为重入) 。

该示例执行 100 个测试运行。 每次运行测试时，计时器的启动间隔为 150 毫秒。 事件处理程序使用 Thread.Sleep 方法来模拟长度从 50 到 200 毫秒随机变化的任务。 测试方法还会启动一个控制线程，该线程等待一秒钟，然后停止计时器。 如果在控制线程停止计时器时正在处理事件，则控制线程必须等待事件完成，然后才能继续。

方法 Interlocked.CompareExchange(Int32, Int32, Int32) 重载用于避免重入，并防止控制线程继续执行，直到执行事件结束。 事件处理程序使用 CompareExchange(Int32, Int32, Int32) 方法将控件变量设置为 1，但前提是该值当前为零。 这是一个原子操作。 如果返回值为零，则控制变量已设置为 1，事件处理程序将继续。 如果返回值为非零，则直接放弃事件以避免重新进入。 (如果需要执行每个事件，类 Monitor 是同步 events 的更好方法。) 事件处理程序结束时，它将控制变量设置回零。 该示例记录在调用 方法后 Stop 执行的、由于重入而放弃的事件总数以及发生的事件总数。

控制线程使用 CompareExchange(Int32, Int32, Int32) 方法将控制变量设置为 -1 (减一) ，但前提是当前值为零。 如果原子操作返回非零，则表示当前正在执行事件。 控制线程将等待并重试。 该示例记录控制线程必须等待事件完成的次数。

using System;
using System.Timers;
using System.Threading;

public class Test
{
    // Change these values to control the behavior of the program.
    private static int testRuns = 100;
    // Times are given in milliseconds:
    private static int testRunsFor = 500;
    private static int timerIntervalBase = 100;
    private static int timerIntervalDelta = 20;

    // Timers.
    private static System.Timers.Timer Timer1 = new System.Timers.Timer();
    private static System.Timers.Timer Timer2 = new System.Timers.Timer();
    private static System.Timers.Timer currentTimer = null;

    private static Random rand = new Random();

    // This is the synchronization point that prevents events
    // from running concurrently, and prevents the main thread
    // from executing code after the Stop method until any
    // event handlers are done executing.
    private static int syncPoint = 0;

    // Count the number of times the event handler is called,
    // is executed, is skipped, or is called after Stop.
    private static int numEvents = 0;
    private static int numExecuted = 0;
    private static int numSkipped = 0;
    private static int numLate = 0;

    // Count the number of times the thread that calls Stop
    // has to wait for an Elapsed event to finish.
    private static int numWaits = 0;

    [MTAThread]
    public static void Main()
    {
        Timer1.Elapsed += new ElapsedEventHandler(Timer1_ElapsedEventHandler);
        Timer2.Elapsed += new ElapsedEventHandler(Timer2_ElapsedEventHandler);

        Console.WriteLine();
        for(int i = 1; i <= testRuns; i++)
        {
            TestRun();
            Console.Write("\rTest {0}/{1}    ", i, testRuns);
        }

        Console.WriteLine("{0} test runs completed.", testRuns);
        Console.WriteLine("{0} events were raised.", numEvents);
        Console.WriteLine("{0} events executed.", numExecuted);
        Console.WriteLine("{0} events were skipped for concurrency.", numSkipped);
        Console.WriteLine("{0} events were skipped because they were late.", numLate);
        Console.WriteLine("Control thread waited {0} times for an event to complete.", numWaits);
    }

    public static void TestRun()
    {
        // Set syncPoint to zero before starting the test
        // run.
        syncPoint = 0;

        // Test runs alternate between Timer1 and Timer2, to avoid
        // race conditions between tests, or with very late events.
        if (currentTimer == Timer1)
            currentTimer = Timer2;
        else
            currentTimer = Timer1;

        currentTimer.Interval = timerIntervalBase
            - timerIntervalDelta + rand.Next(timerIntervalDelta * 2);
        currentTimer.Enabled = true;

        // Start the control thread that shuts off the timer.
        Thread t = new Thread(ControlThreadProc);
        t.Start();

        // Wait until the control thread is done before proceeding.
        // This keeps the test runs from overlapping.
        t.Join();
    }

    private static void ControlThreadProc()
    {
        // Allow the timer to run for a period of time, and then
        // stop it.
        Thread.Sleep(testRunsFor);
        currentTimer.Stop();

        // The 'counted' flag ensures that if this thread has
        // to wait for an event to finish, the wait only gets
        // counted once.
        bool counted = false;

        // Ensure that if an event is currently executing,
        // no further processing is done on this thread until
        // the event handler is finished. This is accomplished
        // by using CompareExchange to place -1 in syncPoint,
        // but only if syncPoint is currently zero (specified
        // by the third parameter of CompareExchange).
        // CompareExchange returns the original value that was
        // in syncPoint. If it was not zero, then there's an
        // event handler running, and it is necessary to try
        // again.
        while (Interlocked.CompareExchange(ref syncPoint, -1, 0) != 0)
        {
            // Give up the rest of this thread's current time
            // slice. This is a naive algorithm for yielding.
            Thread.Sleep(1);

            // Tally a wait, but don't count multiple calls to
            // Thread.Sleep.
            if (!counted)
            {
                numWaits += 1;
                counted = true;
            }
        }

        // Any processing done after this point does not conflict
        // with timer events. This is the purpose of the call to
        // CompareExchange. If the processing done here would not
        // cause a problem when run concurrently with timer events,
        // then there is no need for the extra synchronization.
    }

    // Event-handling methods for the Elapsed events of the two
    // timers.
    //
    private static void Timer1_ElapsedEventHandler(object sender,
        ElapsedEventArgs e)
    {
        HandleElapsed(sender, e);
    }

    private static void Timer2_ElapsedEventHandler(object sender,
        ElapsedEventArgs e)
    {
        HandleElapsed(sender, e);
    }

    private static void HandleElapsed(object sender, ElapsedEventArgs e)
    {
        numEvents += 1;

        // This example assumes that overlapping events can be
        // discarded. That is, if an Elapsed event is raised before
        // the previous event is finished processing, the second
        // event is ignored.
        //
        // CompareExchange is used to take control of syncPoint,
        // and to determine whether the attempt was successful.
        // CompareExchange attempts to put 1 into syncPoint, but
        // only if the current value of syncPoint is zero
        // (specified by the third parameter). If another thread
        // has set syncPoint to 1, or if the control thread has
        // set syncPoint to -1, the current event is skipped.
        // (Normally it would not be necessary to use a local
        // variable for the return value. A local variable is
        // used here to determine the reason the event was
        // skipped.)
        //
        int sync = Interlocked.CompareExchange(ref syncPoint, 1, 0);
        if (sync == 0)
        {
            // No other event was executing.
            // The event handler simulates an amount of work
            // lasting between 50 and 200 milliseconds, so that
            // some events will overlap.
            int delay = timerIntervalBase
                - timerIntervalDelta / 2 + rand.Next(timerIntervalDelta);
            Thread.Sleep(delay);
            numExecuted += 1;

            // Release control of syncPoint.
            syncPoint = 0;
        }
        else
        {
            if (sync == 1) { numSkipped += 1; } else { numLate += 1; }
        }
    }
}

/* On a dual-processor computer, this code example produces
   results similar to the following:

Test 100/100    100 test runs completed.
436 events were raised.
352 events executed.
84 events were skipped for concurrency.
0 events were skipped because they were late.
Control thread waited 77 times for an event to complete.
 */

注解

还可以通过将 设置为 Enabledfalse来停止计时。

备注

引发 Elapsed 事件的信号始终在线程上 ThreadPool 排队等待执行，因此事件处理方法可能在一个线程上运行，同时对 方法的调用 Stop 在另一个线程上运行。 这可能会导致 Elapsed 调用 方法后 Stop 引发 事件。 示例部分中的第二个代码示例演示了解决此争用条件的一种方法。

适用于

产品 版本
.NET Core 2.0, Core 2.1, Core 2.2, Core 3.0, Core 3.1, 5, 6, 7, 8, 9, 10
.NET Framework 1.1, 2.0, 3.0, 3.5, 4.0, 4.5, 4.5.1, 4.5.2, 4.6, 4.6.1, 4.6.2, 4.7, 4.7.1, 4.7.2, 4.8, 4.8.1
.NET Standard 2.0, 2.1

另请参阅