Concurrencia en Java

Concurrencia en Java:
De Iniciado a Competente
Barcamp Santiago, Noviembre 18, 2017

Acerca de Mi.
Pedro J. González.
pjgonzalez@gmail.com
popxix
pjgonzalezdr

Tópicos:
● Thread, Runnable, Callable .
● Synchronized, Atomic.
● Future, ExecutorService.
● ThreadPool, ForkJoinPool
● ForkJoinTask.
● ParallelStream
● Amdhal’s Law

Recursos:
http://tutorials.jenkov.com/java-util-concurrent/index.html
http://www.linfo.org/context_switch.html
https://www.youtube.com/watch?v=HdnHmbFg_hw
https://github.com/popxix/barcamp
https://docs.oracle.com/javase/tutorial/collections/streams/parallelism.html

Thread
● Es un Hilo de Ejecución de un App.
● La JVM permite a un App Java tener múltiples hilos corriendo
concurrente.
● Cada Thread tiene su prioridad.
● Formas de Crear Threads:
○ Extendiendo la clase Thread.
○ Implementando la Interfaz Runnable.

public class AnalizadorWebLogThread extends Thread {
….
public AnalizadorWebLogThread(final File archivo, Predicate<RegistroAcceso> filtro) { ..}
private boolean esValido() {...}
@Override
public void run() {
if(esValido()) {
try {analizaArchivo(Files.lines(archivo.toPath())); } catch
(IOException e) { ...}}
}
protected void analizaArchivo(Stream<String> streamArchivo) {
long total =
streamArchivo.map(AuxFunciones::analizadorLog).filter(filtro).count();
System.out.println(total + " Registros encontrados..");
}
public static void main(String[] args) {
AnalizadorWebLogThread analizadorWebLogThread = new
AnalizadorWebLogThread(archivo, filtro);
analizadorWebLogThread.start();
}
}

Comunicación inter-Thread
Comunicación entre threads sincronizados.
Se lleva a cabo durante el uso de los siguientes métodos de la clase Object:
● Wait(): Causa que el se invoque el bloqueo del thread actual.
● Notify(): Libera el bloqueo.
● NotifyAll()

Diferencia entre wait() y sleep()
wait()
● Libera el proceso de bloqueo.
● Pertenece a la clase Object.
● El bloqueo es liberado Luego de llamar
los métodos notify() y notifyAll()
Sleep()
● No libera bloqueo.
● Pertenece a la clase thread.
● El thread continua su ejecución
después del tiempo especificado.

public class AnalizadorWebLog {
private List<RegistroAcceso> registros = new ArrayList<>();
public synchronized void analizaLog(File archivo) {
System.out.println("Cargando Archivos de log..");
this.registros = archivoALista(archivo,getFiltroIP("192.168.234.82"));
System.out.println("Fueron Cargados.." + registros.size() + " Registros");
notify();
}
public synchronized void insertaLogDB() {
if(registros.isEmpty()) {
System.out.println("No hay archivos procesados en este momento...");
try {wait();} catch (Exception e) {....}}
registros.stream().forEach(registro->{System.out.println(" Procesando el registro de la fecha: " +
registro.getFecha());});}
public static void main(String[] args) {
final AnalizadorWebLog analizadorWebLog = new AnalizadorWebLog();
Runnable dbTask = ()->{analizadorWebLog.insertaLogDB();};
new Thread(dbTask).start();
Runnable analizaTask = ()->{analizadorWebLog.analizaLog(logFile);};
new Thread(analizaTask).run();
}
}

MultiThreading Y Concurrencia
Beneficios
Aun con los retos que presenta la
concurrencia, más abajo se detallan algunos
de sus beneficios:
Que Gano?
● Mejor Utilización de Recursos.
● Diseño del programa más simple.*
● Programa más receptivo.
Sacrificios
Tiene sus costos, sin embargo los beneficios
son mayores que los sacrificios, más abajo se
detalla algunos de sus costos:
Cual es el Costo?
● Complejidad en el diseño.
● Cambio de Contexto.
● Incremento en el consumo de recursos.

Executors
Métodos Utilitarios y Factory las interfaces Executor, ExecutorService y
SchedulerExecutorService. Soporta el Siguiente tipo de métodos:
● Método que crea un y retorna un ExecutorService con la configuración más comunes.
● Método que crea un y retorna un ScheduledExecutorService con la configuración más comunes.
● Método que crea un y retorna un “wrapped” ExecutorService.
● Método que crea un y retorna un ThreadFactory.
● Método que crea un y retorna un Callable.

Executors
● ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();
● ScheduledExecutorService singleScheduledExService = Executors.newSingleThreadScheduledExecutor();
● ExecutorService fixedExecutorService = Executors.newFixedThreadPool(10);
● ExecutorService onDemandExecutorService = Executors.newCachedThreadPool();
● ScheduledExecutorService fixedScheduledExecutorService = Executors.newScheduledThreadPool(5);

ExecutorService
Interfaz que provee un procesamiento asíncrono para la ejecución de tareas.
● shutdown(): permite terminar las tareas las tareas enviadas previo a la llamada del
método. Y no Acepta tareas nuevas.
● shutdownNow(): Evita que las tareas en espera inicien y trata de terminar las
tareas en ejecución.
● Produce un resultado del tipo Future.

Implementaciones:
➔ ThreadPoolExecutor.
Ejecuta la tarea dada (Callable, Runnable) utilizando uno de los Threads agrupados.
int corePoolSize = 5;
int maxPoolSize = 10;
long keepAliveTime = 5000;
ExecutorService threadPoolExecutor = new ThreadPoolExecutor( corePoolSize, maxPoolSize, keepAliveTime,
TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

ScheduledExecutorService
● Tipo de ExecutorService que puede ser utilizado para ejecutar tareas con un
retraso especificado o periódicamente.
● scheduleAtFixedRate y scheduleWithFixedDelay crean y ejecutan tareas que
corren de forma periódica hasta que son canceladas.
private final ScheduledExecutorService scheduler =Executors.newScheduledThreadPool(1);
public void beepForAnHour() {
final Runnable beeper = new Runnable() {
public void run() { System.out.println("beep"); } };
final ScheduledFuture<?> beeperHandle =scheduler.scheduleAtFixedRate(beeper, 10, 10, SECONDS);
scheduler.schedule(new Runnable() { public void run() { beeperHandle.cancel(true); }}, 60 * 60, SECONDS);}

Future
● Representa el resultado pendiente de una operación Asíncrona.
Future<T> ExecutorService.submit(Callable <T> callable)
La llamada al método retorna inmediato pero se debe invocar get() para obtener
el resultado.

CompletableFuture
Implementa las siguientes interfaces:
➔ Future<T>: Resultado Pendiente en una operación asíncrona.
➔ CompletionStage<T>: Una promesa de que la operación en algún momento será completada.
Métodos:
➔ static CompletableFuture supplyAsync(Supplier supplier);
➔ static CompletableFuture supplyAsync(Supplier supplier, Executor executor);
➔ static CompletableFuture<Void> runAsync(Runnable runnable);
➔ static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);

Solo Vale La pena
● Cuando las Operaciones son independientes y asociativas.
○ a op (b op c ) === ( a op) op c.
● Cuando hay muchos datos o se requiere mucho procesamiento por elementos.
○ N * Q > 10000
● Cuando los datos son fáciles de particionar.

Parallel Streams
try(Stream<String> cad = Files.lines(logFile.toPath())){
Long total =
cad.parallel().map(AuxFunciones::analizadorLog)
.filter(....).count();

Amdahl's law
Calculo de cuanto puede incrementar el rendimiento computacional si se corre en paralelo.
Llamada así por Gene Amdahl quien presentó la ley en 1967.
Formula:
T = B + (T-B)
Donde:
T=Tiempo total de la ejecución en serie.
B=Tiempo total de la parte no paralelizada.
T-B = Tiempo de la parte paralelizada (cuando se ejecuta en serie)
Entonces para medir la velocidad de ejecución de la parte paralelizada expresamos:
(T-B) / N
Donde:
N= Número de Threads o CPU (Factor de Paralelización).

Concurrencia en Java

Más contenido relacionado

La actualidad más candente (20)

Similar a Concurrencia en Java (20)

Último (8)

Concurrencia en Java

Notas del editor