Come possiamo salvare un thread per l'attività successiva dopo l'esecuzione in java (Implementazione del pool di thread)

Question

Ho bisogno di chiedere come viene implementato il pool di thread per avere un numero costante di thread in esecuzione ogni volta che si verifica l'invio di attività. (In esecutore evitare ogni creazione filetto tempo e soppressione sovraccarico)

executor.submit(Runnable) 

Diciamo creiamo dei fili in partenza e quando compito venire assegniamo compito loro (Thread) utilizzando qualsiasi impl coda. Ma dopo aver completato s compito come potrebbe un ritorno filo alla piscina di nuovo quando come per il ciclo di vita del filo dice che

"Dopo l'esecuzione del suo metodo run va in stato terminato e non può essere usato di nuovo"

Non riesco a capire come funziona il pool di thread per il numero costante di thread per l'esecuzione di qualsiasi attività nella coda.

Sarebbe bello se qualcuno potesse fornirmi un esempio di riutilizzo dei thread dopo il completamento dell'attività.

!! Grazie in anticipo. !!

Answer 1

"Dopo esecuzione del metodo run va in stato chiuso e non può essere utilizzato nuovamente"

non termina la sua run() Invece ha un ciclo che gestisce il run() dei compiti che fornisci.

---

Semplificando il modello di pool di thread in modo drammatico si dispone di un codice simile a questo.

final BlockingQueue<Runnable> tasks = new LinkedBlockingQueue<Runnable>(); 

public void submit(Runnable runs) { 
    tasks.add(runs); 
} 

volatile boolean running = true; 

// running in each thread in the pool 
class RunsRunnable implement Runnable { 
    public void run() { 
     while(running) { 
      Runnable runs = tasks.take(); 
      try { 
       runs.run(); 
      } catch(Throwable t) { 
       // handles t 
      } 
     } 
    } 
} 

In questo esempio, si può vedere che, mentre la corsa() di ciascun compito completa, il run() del filo stesso non fino alla piscina è arresto.

Answer 2

Potete dare un'occhiata qui: http://www.ibm.com/developerworks/library/j-jtp0730/index.html per maggiori dettagli e un esempio di implementazione. I thread nel pool attenderanno se la coda è vuota e ognuno avvierà i messaggi dopo aver ricevuto la notifica che la coda ha alcuni elementi.

Answer 3

ExecutorService executor = Executors.newFixedThreadPool(2);

- Quanto sopra dichiarato creare lo ThreadPool con dimensione fissa di 2.

executor.execute(new Worker());

- Questa istruzione prende un'istanza della classe lavoratore che ha attuato Runnable Interfaccia.

- Ora qui lo Executors è un oggetto intermedio che esegue l'attività. Che gestisce gli oggetti thread.

- Eseguendo la dichiarazione di cui sopra il metodo run() verrà eseguito, e una volta il metodo run() completa, il filo doesnot andare in stato di morto, ma si muove di nuovo in piscina, in attesa di avere un altro lavoro assegnato ad esso, quindi può ancora una volta passare in stato Runnable e quindi a correre, tutto questo è gestito da Executor.

executor.shutdown();

- che questo arresto dichiarazione volontà esecutori stesso, movimentazione grazia la chiusura di tutti i fili da essa gestiti .. shutdown() su quell'oggetto centrale, che a sua volta potrebbe terminare ciascuna delle esecutori registrati .

////////// Edited Part////////////////////// 

- Prima di tutto Runnable ha un metodo run(), che non possono tornare nulla, e il metodo run() non può lanciare un'eccezione controllata, quindi richiamabile è stato introdotto in Java 5, che è di tipo parametrico, e ha un metodo chiamato call(), ed è in grado di ritornare e lanciare eccezioni controllate.

ora vedere questo esempio:

Thread t = new Thread(new Worker()); 

t.run(); 

t.start(); 

-t.run() è solo una semplice chiamata al metodo run(), questo non si estenderà un thread of execution.

-t.start(), mentre si prepara per le cose importanti per la initialization del thread of execution, e poi chiamate il metodo run() del Runnable, e poi assegnare il Task al nuova formazionethread of execution e restituisce rapidamente ....

I thread in Java diventano una necessità quando si utilizza Swing e AWT. Principalmente il componente della GUI.

Answer 4

Sono totalmente d'accordo con Peter ma voglio aggiungere passaggi relativi al flusso di esecuzione di ExecutorService, per una chiara comprensione.

• Se si crea piscina (piscina fisso dimensioni) di fili che non significa che le discussioni sono state create.
• Se si invia e/o eseguire nuove attività (Runnuble o Callable) nuovo thread verrà creato sporge se conteggio di thread creati < dimensioni della piscina
• thread creati non tornare alla piscina, le discussioni possono attendere per il nuovo valore nel bloccare in coda, questo punto possiamo chiamare RITORNARE ALLA PISCINA
• Tutti i thread degli exec pool come descritto sopra.

Answer 5

Di solito cosa succede quando utilizziamo il pool di thread, il suo metodo Run interno è forzato a eseguire iterativamente. Fino a quando non ci sono attività disponibili nella coda.

nell'esempio seguente pool.removeFromQueue() verrà eseguito in modo iterativo.

public class MyThread<V> extends Thread { 
    private MyThreadPool<V> pool; 
    private boolean active = true; 

    public boolean isActive() { 
     return active; 
    } 

    public void setPool(MyThreadPool<V> p) { 
     pool = p; 
    } 

    /** 
    * Checks if there are any unfinished tasks left. if there are , then runs 
    * the task and call back with output on resultListner Waits if there are no 
    * tasks available to run If shutDown is called on MyThreadPool, all waiting 
    * threads will exit and all running threads will exit after finishing the 
    * task 
    */ 
    @Override 
    public void run() { 
     ResultListener<V> result = pool.getResultListener(); 
     Callable<V> task; 
     while (true) { 
      task = pool.removeFromQueue(); 
      if (task != null) { 
       try { 
        V output = task.call(); 
        result.finish(output); 
       } catch (Exception e) { 
        result.error(e); 
       } 
      } else { 
       if (!isActive()) 
        break; 
       else { 
        synchronized (pool.getWaitLock()) { 
         try { 
          pool.getWaitLock().wait(); 
         } catch (InterruptedException e) { 
          // TODO Auto-generated catch block 
          e.printStackTrace(); 
         } 
        } 
       } 
      } 
     } 
    } 

    void shutdown() { 
     active = false; 
    } 

bisogno di progettare il vostro pool di thread

public MyThreadPool(int size, ResultListener<V> myResultListener) { 
     tasks = new LinkedList<Callable<V>>(); 
     threads = new LinkedList<MyThread<V>>(); 
     shutDown = false; 
     resultListener = myResultListener; 
     for (int i = 0; i < size; i++) { 
      MyThread<V> myThread = new MyThread<V>(); 
      myThread.setPool(this); 
      threads.add(myThread); 
      myThread.start(); 
     } 
    }