Timer.Stop Méthode
Définition
Important
Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.
public:
void Stop();
public void Stop ();
member this.Stop : unit -> unit
Public Sub Stop ()
Exemples
L’exemple suivant instancie un System.Timers.Timer
objet qui déclenche son Timer.Elapsed événement toutes les deux secondes (2 000 millisecondes), configure un gestionnaire d’événements pour l’événement et démarre le minuteur. Le gestionnaire d’événements affiche la valeur de la ElapsedEventArgs.SignalTime propriété chaque fois qu’elle est déclenchée. Lorsque l’utilisateur appuie sur la touche Entrée, l’application appelle la Stop méthode avant de mettre fin à l’application.
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...
open System
open System.Timers
let onTimedEvent source (e: ElapsedEventArgs) =
printfn $"""The Elapsed event was raised at {e.SignalTime.ToString "HH:mm:ss.fff"}"""
// Create a timer with a two second interval.
let aTimer = new Timer 2000
// Hook up the Elapsed event for the timer.
aTimer.Elapsed.AddHandler onTimedEvent
aTimer.AutoReset <- true
aTimer.Enabled <- true
printfn "\nPress the Enter key to exit the application...\n"
printfn $"""The application started at {DateTime.Now.ToString "HH:mm:ss.fff"}"""
stdin.ReadLine() |> ignore
aTimer.Stop()
aTimer.Dispose()
printfn "Terminating the application..."
// 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...
Imports System.Timers
Public Module Example
Private aTimer As System.Timers.Timer
Public Sub Main()
SetTimer()
Console.WriteLine("{0}Press the Enter key to exit the application...{0}",
vbCrLf)
Console.WriteLine("The application started at {0:HH:mm:ss.fff}",
DateTime.Now)
Console.ReadLine()
aTimer.Stop()
aTimer.Dispose()
Console.WriteLine("Terminating the application...")
End Sub
Private Sub SetTimer()
' Create a timer with a two second interval.
aTimer = New System.Timers.Timer(2000)
' Hook up the Elapsed event for the timer.
AddHandler aTimer.Elapsed, AddressOf OnTimedEvent
aTimer.AutoReset = True
aTimer.Enabled = True
End Sub
' The event handler for the Timer.Elapsed event.
Private Sub OnTimedEvent(source As Object, e As ElapsedEventArgs)
Console.WriteLine("The Elapsed event was raised at {0:HH:mm:ss.fff}",
e.SignalTime)
End Sub
End Module
' 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...
L’exemple de code suivant montre une façon d’empêcher le thread qui appelle la Stop méthode de continuer jusqu’à ce qu’un événement en cours d’exécution Elapsed se termine, et également d’empêcher deux Elapsed événements d’exécuter le gestionnaire d’événements en même temps (souvent appelé réentrance).
L’exemple exécute 100 séries de tests. Chaque fois que le test est exécuté, le minuteur est démarré avec un intervalle de 150 millisecondes. Le gestionnaire d’événements utilise la Thread.Sleep méthode pour simuler une tâche dont la longueur varie de façon aléatoire de 50 à 200 millisecondes. La méthode de test démarre également un thread de contrôle qui attend une seconde, puis arrête le minuteur. Si un événement est géré lorsque le thread de contrôle arrête le minuteur, le thread de contrôle doit attendre que l’événement soit terminé avant de continuer.
La Interlocked.CompareExchange(Int32, Int32, Int32) surcharge de méthode est utilisée pour éviter la réentrance et empêcher le thread de contrôle de continuer jusqu’à la fin d’un événement en cours d’exécution. Le gestionnaire d’événements utilise la CompareExchange(Int32, Int32, Int32) méthode pour définir une variable de contrôle sur 1, mais uniquement si la valeur est actuellement égale à zéro. Il s’agit d’une opération atomique. Si la valeur de retour est zéro, la variable de contrôle a été définie sur 1 et le gestionnaire d’événements continue. Si la valeur de retour est autre que zéro, l’événement est simplement ignoré pour éviter la réentrance. (S’il était nécessaire d’exécuter chaque événement, la Monitor classe serait un meilleur moyen de synchroniser les événements.) Lorsque le gestionnaire d’événements se termine, il rétablit la variable de contrôle sur zéro. L’exemple enregistre le nombre total d’événements qui ont été exécutés, qui ont été ignorés en raison d’une réentrance et qui se sont produits après l’appel de la Stop méthode.
Le thread de contrôle utilise la CompareExchange(Int32, Int32, Int32) méthode pour définir la variable de contrôle sur -1 (moins un), mais uniquement si la valeur est actuellement zéro. Si l’opération atomique retourne un autre résultat que zéro, un événement est en cours d’exécution. Le thread de contrôle attend et réessaye. L’exemple enregistre le nombre de fois où le thread de contrôle a dû attendre la fin d’un événement.
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.
*/
open System
open System.Threading
// Change these values to control the behavior of the program.
let testRuns = 100
// Times are given in milliseconds:
let testRunsFor = 500
let timerIntervalBase = 100
let timerIntervalDelta = 20
// Timers.
let timer1 = new Timers.Timer()
let timer2 = new Timers.Timer()
let mutable currentTimer = Unchecked.defaultof<Timers.Timer>
let rand = 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.
let mutable syncPoint = 0
// Count the number of times the event handler is called,
// is executed, is skipped, or is called after Stop.
let mutable numEvents = 0
let mutable numExecuted = 0
let mutable numSkipped = 0
let mutable numLate = 0
// Count the number of times the thread that calls Stop
// has to wait for an Elapsed event to finish.
let mutable numWaits = 0
let 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.
let mutable 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(&syncPoint, -1, 0) <> 0 do
// 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 not counted then
numWaits <- 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.
let 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 then
currentTimer <- timer2
else
currentTimer <- timer1
currentTimer.Interval <-
timerIntervalBase - timerIntervalDelta + (timerIntervalDelta * 2 |> rand.Next)
|> float
currentTimer.Enabled <- true
// Start the control thread that shuts off the timer.
let t = new Thread(ThreadStart controlThreadProc)
t.Start()
// Wait until the control thread is done before proceeding.
// This keeps the test runs from overlapping.
t.Join()
let handleElapsed sender e =
numEvents <- 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.)
//
let sync = Interlocked.CompareExchange(&syncPoint, 1, 0)
if sync = 0 then
// 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.
timerIntervalBase - timerIntervalDelta / 2 + rand.Next timerIntervalDelta
|> Thread.Sleep
numExecuted <- numExecuted + 1
// Release control of syncPoint.
syncPoint <- 0
else if sync = 1 then
numSkipped <- numSkipped + 1
else
numLate <- numLate + 1
// Event-handling methods for the Elapsed events of the two
// timers.
let timer1_ElapsedEventHandler = handleElapsed
let timer2_ElapsedEventHandler = handleElapsed
[<EntryPoint; MTAThread>]
let main _ =
timer1.Elapsed.AddHandler timer1_ElapsedEventHandler
timer2.Elapsed.AddHandler timer2_ElapsedEventHandler
printfn ""
for i = 1 to testRuns do
testRun ()
printf $"\rTest {i}/{testRuns} "
printfn $"{testRuns} test runs completed."
printfn $"{numEvents} events were raised."
printfn $"{numExecuted} events executed."
printfn $"{numSkipped} events were skipped for concurrency."
printfn $"{numLate} events were skipped because they were late."
printfn $"Control thread waited {numWaits} times for an event to complete."
0
// 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.
Imports System.Timers
Imports System.Threading
Public Module Test
' Change these values to control the behavior of the program.
Private testRuns As Integer = 100
' Times are given in milliseconds:
Private testRunsFor As Integer = 500
Private timerIntervalBase As Integer = 100
Private timerIntervalDelta As Integer = 20
' Timers.
Private WithEvents Timer1 As New System.Timers.Timer
Private WithEvents Timer2 As New System.Timers.Timer
Private currentTimer As System.Timers.timer
Private rand As 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 syncPoint As Integer = 0
' Count the number of times the event handler is called,
' is executed, is skipped, or is called after Stop.
Private numEvents As Integer = 0
Private numExecuted As Integer = 0
Private numSkipped As Integer = 0
Private numLate As Integer = 0
' Count the number of times the thread that calls Stop
' has to wait for an Elapsed event to finish.
Private numWaits As Integer = 0
<MTAThread> _
Sub Main()
Console.WriteLine()
For i As Integer = 1 To testRuns
TestRun
Console.Write(vbCr & "Test {0}/{1} ", i, testRuns)
Next
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)
End Sub
Sub 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 Is Timer1 Then
currentTimer = Timer2
Else
currentTimer = Timer1
End If
currentTimer.Interval = timerIntervalBase _
- timerIntervalDelta + rand.Next(timerIntervalDelta * 2)
currentTimer.Enabled = True
' Start the control thread that shuts off the timer.
Dim t As New Thread(AddressOf ControlThreadProc)
t.Start()
' Wait until the control thread is done before proceeding.
' This keeps the test runs from overlapping.
t.Join()
End Sub
Private Sub 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.
Dim counted As Boolean = 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(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 Not counted Then
numWaits += 1
counted = True
End If
End While
' 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.
End Sub
' Event-handling methods for the Elapsed events of the two
' timers.
'
Private Sub Timer1_ElapsedEventHandler(ByVal sender As Object, _
ByVal e As ElapsedEventArgs) Handles Timer1.Elapsed
HandleElapsed(sender, e)
End Sub
Private Sub Timer2_ElapsedEventHandler(ByVal sender As Object, _
ByVal e As ElapsedEventArgs) Handles Timer2.Elapsed
HandleElapsed(sender, e)
End Sub
Private Sub HandleElapsed(ByVal sender As Object, ByVal e As ElapsedEventArgs)
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.)
'
Dim sync As Integer = Interlocked.CompareExchange(syncPoint, 1, 0)
If sync = 0 Then
' No other event was executing.
' The event handler simulates an amount of work
' similar to the time between events, so that
' some events will overlap.
Dim delay As Integer = timerIntervalBase _
- timerIntervalDelta / 2 + rand.Next(timerIntervalDelta)
Thread.Sleep(delay)
numExecuted += 1
' Release control of syncPoint.
syncPoint = 0
Else
If sync = 1 Then numSkipped += 1 Else numLate += 1
End If
End Sub
End Module
' 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.
Remarques
Vous pouvez également arrêter le minutage en définissant sur Enabledfalse
.
Notes
Le signal pour déclencher l’événement Elapsed est toujours mis en file d’attente pour l’exécution sur un ThreadPool thread, de sorte que la méthode de gestion des événements peut s’exécuter sur un thread en même temps qu’un appel à la Stop méthode s’exécute sur un autre thread. Cela peut entraîner la levée de l’événement Elapsed après l’appel de la Stop méthode. Le deuxième exemple de code de la section Exemples montre une façon de contourner cette condition de race.