Thread.Yeld .Net 4

public class ThreadTester
  {
      Thread t1;
      Thread t2;

      private bool _StopJob = true;

      public bool StopJob
      {
          get { return _StopJob; }
          set { _StopJob = true; }
      }

      public ThreadTester()
      {
    
      }

      public void StartMainJob()
      {
          t1 = new Thread(Process1);
          t2 = new Thread(Process2);

          t1.Start();
          t2.Start();
      }

      public void Process1()
      {
          Console.WriteLine("t1:start");
          int a = 0;
      
          while (_StopJob)
          {
            
              a++;

              if ((a % 100) == 0)
              {
                  Console.WriteLine("t1:{0}", a);
                  Thread.Yield();
              }
            

              if ((a % 1000) == 0)
              {
                  Console.WriteLine("t1:End");
                  _StopJob = false;
              }
          }
      }

      public void Process2()
      {
          Console.WriteLine("t2:start");
          int b = 0;

          while (_StopJob)
          {
         
              b++;

              if ((b % 100) == 0)
              {
                  Console.WriteLine("t2:{0}", b);
                  Thread.Yield();
              }
            

              if ((b % 1000) == 0)
              {
                  Console.WriteLine("t2:End");
                  _StopJob = false;
              }
          }      
      }
  }

In questo esempio mi sono prodigato nel comprendere questa novità del Framework 4.0 il Thread.Yield. Sulle prime non è mi stato molto chiaro come concetto ma proprio durante
la fase di debug salta fuori qualcosa di interessante che decisamente mi ha chiarificato il concetto.

Thread.Yield Restituisce true o false se il ns sistema operativo ha consentito ad un altro thread
di proseguire l'attività.

Il concetto di base, dovrebbe già aver logica nella programmazione a Thread, mentre uno e fermo l'altro prosegue nelle sue attività.

In debug fermando l'applicazione sul primo si ha piena evidenza del fatto che il secondo prosegua
serenamente le sue attività, rispetto al solito ... si ha in più la percezione che qualcuno "non si sa chi" ci abbia passato la palla per proseguire il lavoro.

Addio SwitchToThread ...