Informazioni sulla multi threading

Question

Come uccidere il thread? ..... Come riavviarli di nuovo in multi-threading?

Answer 1

avvolgo i thread del mio worker nella loro classe e utilizzo una proprietà terminata per terminare il loop proc proc.

dispiace io non sono una versione di Java a portata di mano in questo momento, ma si dovrebbe ottenere l'idea da questo http://pastie.org/880516

using System.Threading; 

namespace LoaderDemo 
{ 
    class ParserThread 
    { 
     private bool m_Terminated; 
     private AutoResetEvent m_Signal; 
     private string m_FilePath; 
     ... 

     public ParserThread(AutoResetEvent signal, string filePath) 
     { 
      m_Signal = signal; 
      m_FilePath = filePath; 

      Thread thrd = new Thread(this.ThreadProc); 
      thrd.Start(); 
     } 

     public bool Terminated { 
      set { m_Terminated = value; } 
     } 

     private Guid Parse(ref string s) 
     { 
      //parse the string s and return a populated Guid object 
      Guid g = new Guid(); 

      // do stuff... 

      return g; 
     } 

     private void ThreadProc() 
     { 
      TextReader tr = null; 
      string line = null; 
      int lines = 0; 

      try 
      { 
       tr = new StreamReader(m_FilePath); 
       while ((line = tr.ReadLine()) != null) 
       { 
        if (m_Terminated) break; 

        Guid g = Parse(ref line); 
        m_GuidList.Add(g); 
        lines++; 
       } 

       m_Signal.Set(); //signal done 

      } 
      finally 
      { 
       tr.Close(); 
      } 

     } 

    } 
} 

Answer 2

Thread.stop() uccide un thread, ma è sicuramente non fare desidera fare ciò (consultare la documentazione dell'API per una spiegazione). Thread.interrupt() invia una notifica asincrona a un thread, in modo che possa chiudersi automaticamente.

Per un testo completo sul multithreading Java, consiglio B. Goetz, Concorrenza Java in pratica, Addison-Wesley Professional.

Answer 3

Il modo migliore per uccidere un thread è impostare un flag per il thread da guardare. Programma il thread da uscire quando vede che il flag è impostato su true. Non c'è modo di riavviare un thread ucciso.

Answer 4

Poiché il tuo post è taggato "Java", ho una buona idea di ciò che stai dicendo. Diciamo che si avvia un thread facendo:

Thread foo = new Thread(someRunnable); 
foo.start(); 

Ora che destroy e gli amici sono obsoleti, è necessario un modo per uccidere il thread. Fortunatamente per te, c'è sempre stato il concetto di "interruzioni". Basta cambiare la tua eseguibile in modo che, in caso di interruzione, esca. Quindi chiama il metodo interrupt del thread.

foo.interrupt(); 

Se hai scritto il tuo Runnable per gestirlo correttamente, interromperà qualsiasi cosa stia facendo e terminerà.

Answer 5

Se si desidera avviare, arrestare, riavviare le discussioni a volontà, magari usando il Java 5 il pacchetto di concorrenza sarebbe una buona idea. Puoi avere un Executor che farà un po 'di lavoro, e quando hai bisogno che quel po' di lavoro sia fatto di nuovo, puoi semplicemente riprogrammare l'operazione da eseguire nell'esecutore.

Answer 6

Il metodo preferito per un Thread morire è per l'esecuzione del metodo run sino a completamento:

Thread t = new Thread(new Runnable() { 
    public void run() { 
    // Do something... 

    // Thread will end gracefully here. 
    } 
} 

volta un thread muore grazia nell'esempio precedente, il Thread non può essere riavviato. (Cercando di chiamare Thread.start su un filo che è già stato avviato causerà un IllegalThreadStateException.)

In tal caso, si può fare un altro esempio del filo e chiamare start su questo.

Probabilmente un buon posto per ottenere ulteriori informazioni sulla filettatura sarebbe Lesson: Concurrency da The Java Tutorials.

Answer 7

quanto riguarda la tua prima query sul filetto di uccidere:

è possibile trovare ulteriori dettagli sul tema in seguito domande SE:

How to properly stop the Thread in Java?

How can I kill a thread? without using stop();

How to start/stop/restart a thread in Java?

Per quanto riguarda il tuo secondo query di riavvio del thread, non è possibile in java.

Potete trovare sotto i dettagli nella documentazione page

inizio public void()

causa questo thread per iniziare l'esecuzione; la Java Virtual Machine chiama il metodo run di questo thread.

Il risultato è che due thread vengono eseguiti contemporaneamente: il thread corrente (che ritorna dalla chiamata al metodo start) e l'altro thread (che esegue il suo metodo run).

Non è mai legale avviare una discussione più di una volta. In particolare, un thread non può essere riavviato una volta completata l'esecuzione.

Invece di thread normali, è possibile utilizzare l'API simultanea avanzata per la gestione del ciclo di vita dei thread. Date un'occhiata a questo post per i dettagli ExecutorService:

How to properly use Java Executor?