cómo pausar/reanudar un hilo

Question

¿Cómo puedo pausar/reanudar un hilo? Una vez que Join() un hilo, no puedo reiniciarlo. Entonces, ¿cómo puedo iniciar un hilo y hacer que se detenga cada vez que se presiona el botón 'pausa', y reanudarlo cuando se presiona el botón reanudar?

Lo único que hace este hilo, es mostrar texto al azar en un control de etiqueta.

Answer 1

Tal vez el ManualResetEvent es una buena opción. Un ejemplo corto:

private static EventWaitHandle waitHandle = new ManualResetEvent(initialState: true); 

// Main thread 
public void OnPauseClick(...) { 
    waitHandle.Reset(); 
} 

public void OnResumeClick(...) { 
    waitHandle.Set(); 
} 

// Worker thread 
public void DoSth() { 
    while (true) { 
    // show some random text in a label control (btw. you have to 
    // dispatch the action onto the main thread) 
    waitHandle.WaitOne(); // waits for the signal to be set 
    } 
} 

Answer 2

que podría sugerir a leer Threading in C#, by Joe Albahari, particularmente Suspend and Resume sección:

Un hilo puede ser suspendido de forma explícita y se reanuda a través de los métodos obsoletos Thread.suspend y Thread.Resume. Este mecanismo está completamente separado del de bloqueo. Ambos sistemas son independientes y operan en paralelo.

Un hilo puede suspenderse a sí mismo u otro hilo. Llamar a Suspender da como resultado que el hilo ingrese brevemente en el estado SuspendRequested y luego, al llegar a un punto seguro para la recolección de elementos no utilizados, ingrese al estado Suspendido. A partir de ahí, solo se puede reanudar a través de otro hilo que llame a su método Resume. El currículum funcionará solo en un hilo suspendido, no en un hilo bloqueado.

De .NET 2.0, Suspender y Reanudar han sido desaprobados, su uso desaconsejado debido al peligro inherente a la suspensión arbitraria de otro hilo. Si se suspende un hilo que mantiene un bloqueo en un recurso crítico, toda la aplicación (o computadora) puede estancarse. Esto es mucho más peligroso que llamar a Abort, lo que da como resultado la liberación de dichos bloqueos (al menos teóricamente) en virtud del código en los bloques finally.

Answer 3

No es la mejor idea para suspender y reanudar las discusiones manualmente. Sin embargo, puede simular fácilmente este comportamiento utilizando primitivas de sincronización de subprocesos (como ManualResetEvent)

Eche un vistazo a this question, puede que le sea útil.

Pero creo que puede alcanzar fácilmente su objetivo de "mostrar texto aleatorio en un control de etiqueta" por tiempo mediante el uso de temporizadores.

Aquí está un ejemplo rápido usando DispatcherTimer

var timer = new DispatcherTimer(); 
timer.Tick += (s, e) => Label.Text = GetRandomText(); 
timer.Interval = TimeSpan.FromMilliseconds(500); 
timer.Start(); 

Puede hacer una pausa llamando timer.Stop() y luego timer.Start() nuevo para continuar.

Answer 4

Aquí hay dos maneras en que funcionó para mí. Ambos suponen que el hilo de trabajo tiene su propio ciclo de procesamiento.

1. Tener el hilo invocar una devolución de llamada para solicitar permiso para seguir adelante
2. que el padre invocar un método en la clase del hilo para señalar que

El ejemplo de aplicación de consola siguiente muestra ambos enfoques, utilizando una devolución de llamada para pausar/continuar, y un método de trabajador para detenerse.Otra ventaja del método de devolución de llamada es que también es conveniente para reenviar las actualizaciones de estado mientras se comprueba la autorización para continuar.

using System; 
using System.Threading; 

namespace ConsoleApplication7 
{ 
    class Program 
    { 
     static bool keepGoing; 
     static void Main(string[] args) 
     { 
      keepGoing = true; 
      Worker worker = new Worker(new KeepGoingDelegate(KeepGoing)); 
      Thread thread = new Thread(worker.DoWork); 
      thread.IsBackground = true; 
      thread.Start(); 

      while (thread.ThreadState != ThreadState.Stopped) 
      { 
       switch (Console.ReadKey(true).KeyChar) 
       { 
        case 'p': 
         keepGoing = false; 
         break; 
        case 'w': 
         keepGoing = true; 
         break; 
        case 's': 
         worker.Stop(); 
         break; 
       } 
       Thread.Sleep(100); 
      } 
      Console.WriteLine("Done"); 
      Console.ReadKey(); 
     } 

     static bool KeepGoing() 
     { 
      return keepGoing; 
     } 
    } 

    public delegate bool KeepGoingDelegate(); 
    public class Worker 
    { 
     bool stop = false; 
     KeepGoingDelegate KeepGoingCallback; 
     public Worker(KeepGoingDelegate callbackArg) 
     { 
      KeepGoingCallback = callbackArg; 
     } 

     public void DoWork() 
     { 
      while (!stop) 
      { 
       Console.Write(KeepGoingCallback()?"\rWorking":"\rPaused "); 

       Thread.Sleep(100); 
      } 
      Console.WriteLine("\nStopped"); 
     } 

     public void Stop() 
     { 
      stop = true; 
     } 
    } 
}