¿Cómo podemos guardar un hilo para la próxima tarea después de su ejecución en java? (Implementación del conjunto de subprocesos)

Question

Necesito preguntar cómo se implementa la agrupación de subprocesos para tener un número constante de subprocesos cada vez que se produce el envío de tareas. (En Ejecutor para evitar la creación de cada hilo de tiempo y eliminación de arriba)

executor.submit(Runnable) 

digamos que creamos algunos hilos en el inicio y cuando vienen tarea se le asigna la tarea a ellos (Tema) usando cualquier impl cola. Pero después de completar la tarea que s ¿cómo podría una vuelta de rosca a la piscina de nuevo cuando de acuerdo con el ciclo de vida del hilo dice que

"Después de la ejecución de su método run de que entre en estado terminado y no puede ser utilizado de nuevo"

No se entiende cómo funciona el grupo de subprocesos para tener una cantidad constante de subprocesos para la ejecución de cualquier tarea en su cola.

Sería genial si alguien pudiera darme un ejemplo de reutilización de hilo una vez completada la tarea.

!! Gracias de antemano. !!

Answer 1

"Después de la ejecución de su método run de que entre en estado terminado y no puede ser utilizado de nuevo"

No termina su run() su lugar, tiene un bucle que se ejecuta el run() de las tareas que le proporcionas

---

Simplificando el patrón de grupo de subprocesos de manera espectacular, tiene un código que se ve así.

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

En este ejemplo, se puede ver que mientras el run() de cada tarea se completa, el run() del hilo en sí no es hasta la piscina de apagado.

Answer 2

Puede ver aquí: http://www.ibm.com/developerworks/library/j-jtp0730/index.html para más detalles y un ejemplo de implementación. Los subprocesos del grupo esperarán si la cola está vacía y cada uno iniciará los mensajes de consumidores una vez que se les notifique que la cola tiene algunos elementos.

Answer 3

ExecutorService executor = Executors.newFixedThreadPool(2);

- La declaración anterior creó un ThreadPool con tamaño fijo de 2.

executor.execute(new Worker());

- La declaración anterior toma una instancia de la clase trabajadora que ha implementado Runnable Interfaz.

- Ahora aquí el Executors es un objeto intermedio, que ejecuta la tarea. Que maneja los objetos de hilo.

- Mediante la ejecución de la declaración anterior del método run() se ejecutará, y una vez que el método run() finaliza, el hilo doesnot entrar en estado de muerte sino que se mueve de nuevo en la piscina, a la espera de tener otro trabajo asignado para ello, por lo que una vez más puede pasar al estado Runnable y luego a la ejecución, todo esto es manejado por los ejecutores.

executor.shutdown();

- La declaración anterior se apagará la propia Ejecutores, la manipulación con gracia el cierre de todos los subprocesos administrados por ella .. shutdown() en ese objeto central, que a su vez podría terminar cada uno de los ejecutores registrados .

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

- En primer lugar Ejecutable tiene un método run(), que no puede devolver nada, y el método run() no puede lanzar una excepción comprobada, tanto rescatable fue introducido en Java 5, que es de tipo paramétrico, y tiene un método llamado call(), y es capaz de devolver y lanzar excepciones Checked.

Ahora ver este ejemplo:

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

t.run(); 

t.start(); 

-t.run() es sólo una simple llamada al método run(), esto no tendrá una duración de unthread of execution.

-t.start() mientras que se prepara para las cosas importantes para la initialization del thread of execution, y luego llamadas el método run() del Runnable, y luego asignar la Task a la recién formadothread of execution y regresa rápidamente ....

Los hilos en Java se vuelven una necesidad cuando se usan Swing y AWT. Principalmente el componente GUI.

Answer 4

Estoy totalmente de acuerdo con Peter, pero quiero agregar pasos relacionados con el flujo de ejecución ExecutorService, para una comprensión clara.

• Si crea piscina (piscina de tamaño fijo) de hilos que no significa que se crearon las discusiones.
• Si envía y/o ejecutar nuevas tareas (Runnuble o Callable) nuevo hilo se creará adentra si el recuento de subprocesos creados < tamaño de la piscina
• Creado hilos no regresan a la piscina, hilos puede esperar a un nuevo valor en el bloqueo cola, este punto podemos llamar DEVOLVER A PISCINA
• Todos los hilos de ejecutivos de pool como Peter descritos anteriormente.

Answer 5

Por lo general, lo que sucede cuando utilizamos el grupo de subprocesos, su método dentro de ejecución se ejecuta de forma iterativa. Hasta que haya tareas disponibles en la cola.

en el ejemplo siguiente pool.removeFromQueue() se ejecutará de forma iterativa.

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

necesidad de diseñar su grupo de subprocesos

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