reusage filo java via esecutore

Question

Sono confuso su quanto segue:
Per utilizzare thread in un programma Java, il modo più semplice è quello di estendere classe Thread e implementare l'interfaccia eseguibile (o semplicemente implementare eseguibile).
Per avviare l'esecuzione del thread. dobbiamo chiamare il metodo di avvio del thread (), che a sua volta chiama il metodo run () del thread. E così inizia la filettatura.
Il metodo start () (a meno che non mi sbaglio) deve essere chiamato esattamente e solo una volta per ciascun thread. Di conseguenza, le istanze di thread non possono essere riutilizzati a meno che in qualche modo il metodo di esecuzione stesso viene eseguito in alcuni-corto di ciclo infinito che facilita un'implementazione personalizzata del nuovo utilizzo del thread.
Ora il javadoc testo del link  dice

  

chiamate per eseguire riutilizzerà le discussioni precedentemente costruiti, se disponibili

Non capisco come questo è implementato. Fornisco nel metodo execute del metodo esecutore mio thread su misura per es.

  ExecutorService myCachedPool = Executors.newCachedThreadPool();
  myCachedPool.execute(new Runnable(){public void run(){  
     //do something time consuming

  }});

Come può questa discussione personalizzato ho delegeate al quadro esecutore essere riutilizzato?
È Esecutore è permesso di chiamare metodo start () più di 1 volta, mentre non possiamo nei nostri programmi? Am I incomprensione qualcosa?

Grazie.

Answer 1

Si noti che non è Executor che le chiamate start() - è ExecutorService. E no, non sta chiamando start() due volte. Essa non avvia il compito che si dà direttamente utilizzando Thread.start() ... invece, inizia un thread che conosce coda del pool di thread di lavoro. Il filo sarà essenzialmente aspettare fino a quando c'è un po 'di lavoro da fare, poi raccoglierlo e eseguirlo, prima di tornare a in attesa. Quindi, anche se sulle prestazioni del filo diverse attività, Thread.start() viene chiamato una sola volta.

EDIT:. A giudicare dai commenti, sei un po 'confuso circa la differenza tra un Runnable (che è un compito da eseguire) ed un Thread (che è quello che esegue i compiti)

Lo stesso filo in grado di eseguire più attività. Per un esempio molto semplice che non utilizzano un pool di thread, considerare questo:

public class MultiRunnable implements Runnable
{
    private final List<Runnable> runnables;

    public MultiRunnable(List<Runnable> runnables)
    {
        this.runnables = runnables;
    }

    public void run()
    {
        for (Runnable runnable : runnables)
        {
             runnable.run();
        }
    }
}

(ignorare i potenziali problemi di sicurezza filo di utilizzare un List<T> da più thread.)

Si potrebbe creare un sacco di compiti Runnable capaci di fare cose diverse, quindi creare un unico MultiRunnable per farli funzionare a turno. Passare l'istanza di MultiRunnable al costruttore Thread, e poi, quando si avvia il filo, si eseguirà ciascuna delle attività eseguibili originali. Fa che aiutano?

Answer 2

Non chiama start () più di una volta; invece il filo in piscina non viene completata, ma solo rimane vivo --- attesa. Il codice sorgente è disponibile per il download, se si vuole guardare.

Ogni thread nel pool di thread può semplicemente wait() per l'Esecutore a portata di mano un nuovo Runnable, ma proprio metodo run() del thread non è stata completata. Si attende semplicemente per una nuova Runnable da dare l'Esecutore.

Answer 3

Per "start" un filo più di una volta, creare un eseguibile. Ad esempio:

//NO
private class T extends Thread { //not necessary to implement runnable
    public void run(){
        //...
    }
}
void someMethod(){
    T a = new T();
    a.start();
    a.start(); //NO NO NO NO NO NO NO NO NO NO NO NO NO NO NO NO NO
}

Invece,

//Yes
private class T implements Runnable {
    public void run(){
        //...
    }
}
void someMethod(){
    T a = new T();
    new Thread(a).start();
    new Thread(a).start(); //YES YES YES
}

E 'anche possibile fare questo:

void someMethod(){
    final Runnable r = new Runnable(){
        public void run(){
            //...
        }
    };
    new Thread(r).start();
    new Thread(r).start();
}
// r could also be a field of you class.