come mettere in pausa/riprendere una discussione

Question

Come posso mettere in pausa/riprendere una discussione? Una volta che ho Join() un thread, non riesco a riavviarlo. Quindi, come posso avviare un thread e metterlo in pausa ogni volta che viene premuto il pulsante "pause" e riprenderlo quando viene premuto il pulsante Riprendi?

L'unica cosa che questo thread fa è mostrare del testo casuale in un controllo etichetta.

Answer 1

Forse il ManualResetEvent è una buona scelta. Un breve esempio:

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

potrei suggerire di leggere Threading in C#, by Joe Albahari, in particolare Suspend and Resume sezione:

Un thread può essere sospeso e ripreso esplicitamente tramite i metodi deprecati Thread.Suspend e Thread.Resume. Questo meccanismo è completamente separato da quello del blocco. Entrambi i sistemi sono indipendenti e funzionano in parallelo.

Un thread può sospendere se stesso o un altro thread. Chiamando Suspend i risultati nel thread entrano brevemente nello stato SuspendRequested, quindi al raggiungimento di un punto sicuro per la garbage collection, esso entra nello stato Sospeso. Da lì, può essere ripreso solo tramite un altro thread che chiama il suo metodo Resume. Resume funzionerà solo su un thread sospeso, non su un thread bloccato.

Da .NET 2.0, Sospensione e Riprendi sono stati deprecati, il loro utilizzo scoraggiato a causa del pericolo inerente alla sospensione arbitraria di un altro thread. Se un thread in possesso di un blocco su una risorsa critica è sospeso, l'intera applicazione (o computer) può deadlock. Questo è molto più pericoloso che chiamare Abort - il che si traduce in eventuali blocchi di questo genere rilasciati (almeno teoricamente) in virtù del codice in blocchi alla fine.

Answer 3

Non è la migliore idea di sospendere e riprendere le discussioni manualmente. Tuttavia, è possibile simulare facilmente questo comportamento utilizzando le primitive di sincronizzazione dei thread (come ManualResetEvent)

Dai un'occhiata a this question, potresti trovarlo utile.

Ma credo che si possa raggiungere facilmente il proprio obiettivo di "mostrare testo casuale in un controllo etichetta" su base temporale utilizzando i timer.

Ecco un rapido esempio utilizzando DispatcherTimer

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

È possibile mettere in pausa chiamando timer.Stop() e poi timer.Start() per riprendere.

Answer 4

Ecco due modi per cui ha funzionato. Entrambi presuppongono che il thread di lavoro abbia il proprio ciclo di elaborazione.

1. avere la discussione invocare una richiamata per richiedere il permesso di andare avanti
2. Avere il genitore invocare un metodo su di classe del thread per segnalarlo

L'esempio di applicazione di console in basso mostra entrambi gli approcci, utilizzando un callback per mettere in pausa/continuare e un metodo di lavoro per fermarsi.Un altro vantaggio del metodo di callback è che è anche conveniente per il passaggio degli aggiornamenti di stato mentre sta controllando il permesso di continuare.

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; 
     } 
    } 
}