PDF de programación - PROGRAMACION CONCURRENTE Y DISTRIBUIDA - IV.1 Executor framework: Threads pool

PROGRAMACION CONCURRENTE Y

DISTRIBUIDA

IV.1 Executor framework: Threads pool

J.M.Drake
L.Barros

Notas:

1

Tareas y Threads

Existen dos modelo básicos de programas concurrentes:
Un programa resulta de la actividad de objetos activos que interaccionan entre si

directamente (peer to peer) o a través de recursos y servicios pasivos.

Un programa resulta de la ejecución concurrente de tareas. Cada tarea es una

unidad de trabajo abstracta y discreta que idealmente puede realizarse con
independencia de las otras tareas.

En las aplicaciones con estrategia cliente/servidor, las tareas resultan:
Para implementar los clientes
En los servidores para atender los requerimientos de los clientes.

Organizar las actividades de los servicios como tareas concurrentes:
Incrementa la capacidad de prestar servicios (throughput).
Mejora los tiempos de respuesta (responsiveness) con carga de trabajo normal.
Presenta una degradación gradual de prestaciones cuando la carga se incrementa.

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

2

Notas:

Modelo cliente/servidor

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

3

www.gratisblog.com

Notas:

Estrategias de ejecución de las tareas

Hay diferentes estrategias para ejecutar las tareas que
constituyen un programa:
Ejecución secuencial de las tareas.

Ofrecen bajo throughput y tiempo de respuesta.
Creación explícita de un thread por cada tarea.

La ejecución concurrente de las tareas mejora el uso de los recursos.
Cuando las tareas son muy breves, la creación/destrucción de thread

supone una sobre carga relevante.

Con baja carga tiene buena respuesta. Con alta carga tiene peligro de fallo

por agotamiento de los recursos.

Creación de un grupo de thread (pool) para posteriormente aplicarlos

Se elimina la sobrecarga de creación y destrucción de thread.
Se limita la cantidad de recursos que se acaparan.
Se consigue la estabilidad con alta carga.

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

4

Notas:

Tres políticas de ejecución de tareas

Thread simple

For cada tarea

Ejecuta tarea i

Un thread por tarea

Thread

Thread

Thread

Tarea 1

Tarea 2

Tarea n

Pool

Thread

Thread

Thread

Tarea 1

Tarea 2

Tarea n

Thread pool

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

5

Notas:

Executor framework

Executor es la base de un framework flexible y potente de ejecución
asíncrona de tareas que independiza la definición de las tareas como
unidades lógicas de trabajo y los threads como los mecanismos con los que
las tareas se ejecutan concurrentemente y asíncronamente.
Tiene como objeto diferenciar la interfaz java.util.concurrent.Executor:

public interface Executor{

void execute(Runnable command);

}

Flexibiliza el mantenimiento de programas concurrentes a lo largo de su
ciclo de vida, posibilitando el cambio de las políticas de ejecución sin
cambiar el código de la propia ejecución.

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

6

Notas:

Ejemplo de aplicación del framework Executor (1)

public class Tarea implements Runnable{

// Atributos
String nombre;
// Constructor
public Tarea(String elNombre){

nombre=elNombre;

}
// Tarea realizar
public void run(){

buscaEImprime(nombre);
}

}

}

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

7

Notas:

Ejemplo de aplicación del framework Executor (2)
import java.util.*;
import java.util.concurrent.*;
public class Gestor {

public static void main(String[] args) {

Vector<String> listaNombres=new Vector<String>();
listaNombres.add(“-”);
//Executor exec=new ThreadPerTaskExecutor();
//Executor exec=new OneThreadExecutor();
final Executor exec= Executors.newFixedThreadPool(10);

try{Sopa.cargaSopa(args[0]);}catch(IOException e){};

while (listaNombres.size()!=0){

try{listaNombres=Sopa.leeNombres();} catch (IOException e){}
for (int i=0; i<listaNombres; i++){

exec.execute (new Tarea(listaNombres.elementAt(i))); }

}

}

}

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

8

Notas:

Implementación de ejecutores

import java.util.concurrent.*;
public class ThreadPerTaskExecutor implements Executor{

public void execute(Runnable r){

new Thread(r).start();

}

}

import java.util.concurrent.*;
public class OneThreadExecutor implements Executor{

public void execute(Runnable r){

r.run();

}

}

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

9

Notas:

Políticas de ejecución

La utilidad de usar el framework Executor es poder modificar la política
de ejecución de un conjunto de tareas con sólo el cambio mínimo de
declarar un tipo de ejecutor diferente.
Una política de ejecución incluye:
Definir en que thread se ejecutan las tareas.
Definir el orden en el que se ejecutan las tareas (FIFO,LIFO, Por Prioridad,

etc.

El número de tareas que se permiten ejecutar concurrentemente.
El número de tareas que pueden encolarse en espera de ejecución.
Selección de la tarea que debe ser rechazada si hay sobrecarga.
Definir las acciones que deben ejecutarse antes y después de ejecutarse una

tarea.

La política de ejecución de tareas en una herramienta de gestión de
recursos, y la óptima en cada caso depende de los recursos disponibles y
de la calidad de servicio (throughput )que se requiere para la ejecución.

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

10

Notas:

Thread pools

Un thread pool es una estructura que gestiona un conjunto
homogéneo de threads dispuestos a ejecutar la tarea que se les
encargue a través de una cola de trabajos
El ciclo de vida de un thread de un thread pool es muy simple:

Espera en la cola de trabajo un nuevo trabajo.
Los ejecuta
Retorna a la cola a esperar el siguiente

Ejecutar tareas a través de un pool de threads tiene ventajas:
Reutilizar Thread ya creados implica ahorrase la actividades de

creación y destrucción de nuevas tareas

Disminuye el tiempo de respuesta, ya que las tareas están creadas

cuando llega el requerimiento de ejecución del trabajo.

Regulando la dimensión del pool se puede equilibrar la carga con los

recursos de CPU y memoria que se requieren.

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

11

Notas:

Servidor Web I

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

12

Notas:

Servidor Web II: creación de un thread por cada
petición

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

13

Notas:

Servidor Web III: Solución

Si la solicitud simplemente crea un nuevo hilo para cada
nueva petición HTTP y el sistema recibe más peticiones de las
que puede manejar de inmediato, la aplicación de pronto
dejará de responder a todas las solicitudes.
Con un límite en el número de los hilos que se pueden crear,
la aplicación no servirá a las solicitudes HTTP tan pronto
como entren, pero el servicio será lo más rápido que el
sistema puede soportar.
Una ventaja importante del pool de threads fijo es que las
aplicaciones que lo utilizan se degradan gradualmente.

Procodis’09: IV.1- Executor framework: Thread J.M.Drake L.Barros

14

Notas:

Clase ThreadPoolExecutor

Las instancias Java de thread pool se declaran con la clase java.util.concurrent.
ThreadPoolExecutor que implementa ExecutorService (extends Executor):

class ThreadPoolExecutor implements ExecutorService(

int corePoolSize, // Número base de thread que se crean en el pool
int maximumPoolSize, // Número máximo de threads que se pueden crear en el pool
long keepAliveTime, TimeUnit unit, // Tiempo en el que los thread que hay en

// exceso respecto de corePoolSize se destruyen

BlockingQueue<Runnable> workQueue, //Tipo de cola de tareas del pool
ThreadFactory threadFactory, //Define la política con las que se crean los thread

// dinámicamente (Prioridad, Grupo, naturaleza)

RejectedExecutionHandler handler) // Define la política con la que se descartan las
// tareas cuya ejecución es rechazada, Bien por el proceso de shutdown
// o por que la cola de tareas es acotada.

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

15

)

Notas:

Ejecutores definidos en las librerías Java

En java.util.concurrent.executors hay cuatro factories que
generan intancias concretas que implementan Executor y
ofrecen políticas de ejecución diferentes:
newFixedRhreadPool(int nThreads ) => Genera un pool de threads
con un número de elementos constantes. Si alguno de ellos muere es
sustituido por otro.

newCachedThreadPool() => Genera un pool un número base de

threads. Este número se incrementa si la carga de trabajo del thread
crece.

newSingleThreadExecutor() => crea un único thread que ejecuta

secuencialmente las tareas que se le encominedan. Si el thread muere
es sustituido por otro.

newScheduledThreadPool(int nThread) =>Crea un pool de threads con

un número de elemento prejijado. Los threads ofrecen la interfaz
ScheduledExecutorService con la que se puede planificar la ejecución
periodica de los threads.

Procodis’09: IV.1- Executor framework: Thread pool José M.Drake L.Barros

16

Notas:

Ejemplo

Ejemplo:
Sistema inactivo
llegan 10 tareas simultáneamente
pasan 10 segundos
llegan 5 tareas simultáneamente
pasan 5 minutos
Llegan 20 tareas simultáneamente.
Cada tarea toma entre 5 y 15 segundos