Chronomètre temps écoulé fil de sécurité

Question

J'ai une question assez simple à laquelle je n'ai pas trouvé de réponse concise. Je me demande si je dois me préoccuper d'appeler un lock() lors de la lecture de la propriété écoulée d'un Stopwatch pendant qu'il est encore en marche.

Il s'agit également d'un Stopwatch ce que je devrais utiliser pour mesurer les durées d'exécution d'un thread. J'ai lu dans d'autres questions similaires qu'un DispatchTimer pourrait être utilisé. J'ai également envisagé d'utiliser des événements, mais cela m'a semblé beaucoup de frais généraux pour quelque chose d'aussi simple, merci de m'informer si c'est tout simplement faux et que je devrais utiliser des événements. Un peu de code simple pour illustrer ce dont je parle.

 class foo
 {
      private bool _isRunning { get; set; }
      private Stopwatch sw { get; set; }
      public void StartThread()
      {
          this._isRunning = true;
          new Thread(new ThreadStart(this.DoWork)).Start();
          this.sw.Restart();
      }     
      public void StopThread()
      {
          this._isRunning = false;
          this.sw.Stop();
      }
      private void DoWork()
      {
          while(this._isRunning)
          {
               //Do Stuff
          }
      }
      public TimeSpan GetRuntime()
      {
          return this.sw.Elapsed;
      }
      public foo()
      {
          _isRunning = false;
          sw = new Stopwatch();
      }
 }

Supposons que, dans une application utilisant la classe ci-dessus, j'appelle GetRuntime() d'un autre fil de discussion avant d'arrêter le Stopwatch aurais-je besoin d'ajouter un lock() pour m'assurer que j'obtiens les données correctes et que je ne bloque pas l'instruction Stopwatch de continuer à courir. Ou bien ai-je raison de penser qu'il n'a pas besoin d'un lock() et sera très bien en l'état.

Je comprends que vous pouvez théoriquement effectuer autant de lectures que vous le souhaitez, mais je suis curieux de savoir si cela a changé les choses ou non, étant donné que la mémoire de sauvegarde des propriétés écoulées est constamment écrite. J'ai lu beaucoup d'informations sur la sécurité des threads, mais je cherche juste une clarification et la confirmation que j'ai bien réfléchi à ce sujet.

Answer 1

En Documentation MSDN indique, en ce qui concerne Stopwatch, que "les membres de l'instance ne sont pas garantis comme étant à l'abri des erreurs". Notez qu'il y a certainement une vulnérabilité théorique ici, car il utilise un compte de tic-tac "long" en interne et la mise à jour d'un long sur les processeurs 32 bits n'est pas une opération atomique. Vous pouvez potentiellement voir des valeurs partiellement mises à jour (et donc corrompues). Vous ne le remarquerez probablement pas jusqu'à ce que Ticks dépasse la limite des 32 bits, et vous pourriez alors rencontrer une erreur rare et inattendue (vous pourriez potentiellement lire Int32.MaxValue, suivi de 0, suivi de Int32.MaxValue + 1, ce qui produirait une très grande différence dans les temps écoulés si vous l'interrogiez au mauvais moment).