java - run - Cómo un grupo de subprocesos en caché reutiliza subprocesos existentes

objetos runnable en java

Question

Acabo de empezar a buscar en la clase Executors de Java y en el método newCachedThreadPool( ) . Según la API, el grupo de hilos resultante reutiliza los objetos Thread existentes para nuevas tareas.

Estoy un poco sorprendido de cómo se implementa esto porque no pude encontrar ningún método en la API Thread que te permita establecer el comportamiento de un objeto Thread existente.

Por ejemplo, puede crear un nuevo Thread desde un objeto Runnable , lo que hace que Thread llame al Runnable run( ) Runnable . Sin embargo, no hay ningún método de establecimiento en la API Thread que toma un Runnable como argumento.

Apreciaría cualquier puntero.

Answer 1

Básicamente imagina cada hilo de la piscina haciendo esto:

public void run() {
    while(true) {
        if(tasks available) {
           Runnable task = taskqueue.dequeue();
           task.run();
        } else {
           // wait or whatever
        }
    }
}

Answer 2

Bueno, el hilo solo tiene que llamar a Runnable.run() en los runnables que le son asignados ...

Answer 3

El grupo de subprocesos tiene subprocesos que buscan trabajos ejecutables. En lugar de iniciar un nuevo hilo desde Runnable el hilo solo llamará a la función run() . Por lo tanto, un subproceso en un ThreadPool no se crea con el Runnable que proporcionas, sino con uno que simplemente comprueba si alguna tarea está lista para ejecutarse y la llama directamente.

Así se vería algo como esto:

while(needsToKeepRunning()){
    if(hasMoreTasks()){
        getFirstTask().run();.
    }
    else
    {
        waitForOtherTasks();
    }
}

Por supuesto, esto se simplifica demasiado, la implementación real con la espera es mucho más elegante. Una gran fuente de información sobre cómo funciona esto realmente se puede encontrar en Concurrencia en la práctica.

Answer 4

Los ejecutivos hacen todo por ti en el fondo. Y sí, utiliza la API de subproceso existente solamente.

El siguiente enlace tiene una implementación de ejemplo de Thread pool implementado utilizando la clase Thread y la API de colección: http://www.ibm.com/developerworks/library/j-jtp0730/index.html

Answer 5

Los subprocesos se crean solo una vez en la API del conjunto de subprocesos (excepto en los casos en que, debido a alguna excepción, el subproceso se cierra abruptamente)

Los subprocesos de trabajo sondean la cola para ver si hay una tarea y usarla. Así que los hilos nunca salen.

Es solo una abstracción que los subprocesos se reutilizan (la abstracción para que nunca se detenga). Obviamente, se detienen después de un tiempo de inactividad y una solicitud de apagado.

Runnable -----> Grupos de subprocesos (algunos subprocesos de trabajo consumen ese Runnable y otros esperan más Runnables)

Answer 6

Una explicación simplificada es que cuando pasa un Runnable al ExecutorService, el Runnable se pone en una cola. Los subprocesos de trabajo de ThreadPool se leen de esta cola e invocan el método runnables run () en cola.