Presentación de PowerPointexpertojava.ua.es/dadm/restringido/java/traspas/sesion05-traspas.pdf ·...

© 2012-2013 Depto. Ciencia de la Computación e IA

Experto Universitario en Desarrollo de Aplicaciones para Dispositivos Móviles

Lenguaje Java

Sesión 5: Hilos


Java © 2012-2013 Depto. Ciencia de la Computación e IA Hilos-2

Índice

• Creación de hilos y ciclo de vida• Sincronización de hilos• Bloques vigilados• Interbloqueos• Interfaz Lock• Variables atómicas y colecciones• Ejecutores y pools


Hilos

• Cada hilo es un flujo de ejecución independiente

• Tiene su propio contador de programa

• Todos acceden al mismo espacio de memoria

• Necesidad de sincronizar cuando se accede concurrentemente a los recursos

• Existen estructuras de datos sincronizadas (ej, Vector) y sin sincronizar (ej, ArrayList)


Creación de Hilos

• Se pueden crear de dos formas:• Heredando de Thread

• Problema: No hay herencia múltiple en Java

• Implementando Runnable

• Debemos crear sólo los hilos necesarios• Dar respuesta a más de un evento

simultáneamente

• Permitir que la aplicación responda mientras está ocupada

• Aprovechar máquinas con varios procesadores


Heredar de Thread

• Heredar de Thread y sobrecargar run( )public class MiHilo extends Thread { public void run() { // Codigo de la tarea a ejecutar en el hilo }}

• Instanciar el hiloThread t = new Thread(new MiHilo());

t.start();


Implementar Runnable

• Implementar Runnablepublic class MiHilo implements Runnable {

public void run() {

// Codigo de la tarea a ejecutar en el hilo

}

}

• Instanciar el hiloThread t = new Thread(new MiHilo());

t.start();


Ciclo de vida de los hilos

El hilo será no ejecutable cuando:• Se encuentre durmiendo (llamando a sleep)

• Se encuentre bloqueado (con wait)

• Se encuentre bloqueado en una petición de E/S


Scheduler

El scheduler decide qué hilo ejecutable ocupa el procesador en cada instante

Se sacará un hilo del procesador cuando:

• Se fuerce la salida (llamando a yield)

• Un hilo de mayor prioridad se haga ejecutable

• Se agote el quantum del hilo

Establecemos la prioridad con t.setPriority(prioridad);

• La prioridad es un valor entero entre

Thread.MIN_PRIORITY y Thread.MAX_PRIORITY


Concurrencia y sección crítica

Cuando varios hilos acceden a un mismo recurso pueden producirse problemas de concurrencia

Sección crítica: Trozo del código que puede producir problemas de concurrencia

Debemos sincronizar el acceso a estos recursos• Este código no debe ser ejecutado por más de un

hilo simultáneamente

Todo objeto Java (Object) tiene una variable cerrojo que se utiliza para indicar si ya hay un hilo en la sección crítica

• Los bloques de código synchronized utilizarán este cerrojo para evitar que los ejecute más de un hilo



Bloques sincronizados

• Para sincronizar un bloque de código podemos indicarle el objeto cuyo cerrojo utilizaremos.

• El cerrojo (lock) se adquiere al inicio de la sección crítica y se libera al final de ésta

• Otro hilo no podrá adquirir ese mismo cerrojo al mismo tiempo

synchronized(algun_objeto) { // Código sección crítica }


Métodos sincronizados

• Sincronzar un método o una sección de código

public synchronized void seccion_critica() {

// Codigo

}

• Se utiliza el cerrojo del objeto en el que se definen (cerrojo implícito)

• Se podrán ejecutar por un sólo hilo en un instante dado.


Uso de la sincronización

Deberemos utilizar la sincronización sólo cuando sea necesario, ya que reduce la eficiencia

No sincronizar métodos que contienen un gran número de operaciones que no necesitan sincronización

• Reorganizar en varios métodos

No sincronizar clases que proporcionen datos fundamentales

• Dejar que el usuario decida cuando sincronizarlas en sus propias clases



Sincronización reentrante

La sincronización en Java es “reentrante” porque un lock puede ser adquirido varias veces por un mismo hilo. Es decir, en el mismo hilo, una sección sincronizada puede contener a otra y esto no produce un bloqueo a pesar de que las dos adquieren el lock del objeto this:class Reentrant { public synchronized void a() { b(); System.out.println(" estoy en a() "); } public synchronized void b() { System.out.println(" estoy en b() "); }}


Dependencia de hilos

• Podemos esperar a que un hilo haya acabado de ejecutarse para poder continuar otro hilo

• Para ello bloquearemos el hilo actual que debe esperar a otro hilo t con:

t.join();


Bloqueo de hilos

• Si el hilo va a esperar a que suceda un evento (por ejemplo, terminar una E/S), hay que bloquearlo para que no ocupe el procesador:

wait();

• Cuando suceda el evento debemos desbloquearlo desde otro hilo con:

notify();

• Ambos métodos deben ser invocados desde métodos sincronizados



Bloques vigilados

• En lugar de esperar iterativamente (que ocupa la CPU):

• Bloquear el hilo y esperar una notificación por parte de otro.

public void bloqueVigilado() { // No hacerlo así! while(!condicion) {} // Se detiene aquí, //comprobando iterativamente la condición System.out.println("La condición se ha cumplido");}

public synchronized bloqueVigilado() { while(!condicion) { try { wait(); // desocupa la CPU } catch (InterruptedException e) {} } System.out.println("La condición se ha cumplido");}



Ejemplo: productor/consumidor

• El productor produce si el buffer no está lleno, y si no debe esperar

• El consumidor consume si el buffer no está vacío, y si no debe esperar



Productor import java.util.Random;

public class Producer implements Runnable { private Drop drop; public Producer(Drop drop) { this.drop = drop; } public void run() { String importantInfo[] = { "Mares eat oats", "Does eat oats", "Little lambs eat ivy", "A kid will eat ivy too" }; Random random = new Random(); for (int i = 0; i < importantInfo.length; i++) { drop.put(importantInfo[i]); try { Thread.sleep(random.nextInt(5000)); } catch (InterruptedException e) {} } drop.put("DONE"); }}



Consumidor import java.util.Random;

public class Producer implements Runnable { private Drop drop; public Producer(Drop drop) { this.drop = drop; } public void run() { String importantInfo[] = { "Mares eat oats", "Does eat oats", "Little lambs eat ivy", "A kid will eat ivy too" }; Random random = new Random(); for (int i = 0; i < importantInfo.length; i++) { drop.put(importantInfo[i]); try { Thread.sleep(random.nextInt(5000)); } catch (InterruptedException e) {} } drop.put("DONE"); }}



Recurso public class Drop { // Message sent from producer // to consumer. private String message; // True if consumer should wait // for producer to send message, // false if producer should wait for // consumer to retrieve message. private boolean empty = true; public synchronizedsynchronized String taketake() { // Wait until message is // available. while (empty) { try { wait(); } catch (InterruptedException e) {} } // Toggle status. empty = true; // Notify producer that // status has changed. notifyAll(); return message; } // ...

// ... public synchronizedsynchronized void putput(String message) { // Wait until message has // been retrieved. while (!empty) { try { wait(); } catch (InterruptedException e) {} } // Toggle status. empty = false; // Store message. this.message = message; // Notify consumer that status // has changed. notifyAll(); } }

//Main class:

public class ProducerConsumerExample { public static void main(String[] args) { Drop drop = new Drop(); (new Thread(new Producer(drop))).start(); (new Thread(new Consumer(drop))).start(); }}



Interbloqueos

• Deadlock: hilo A queda a la espera de que B lo desbloquee, a la vez que B queda a la espera de que A lo desbloquee: se interbloquean sin usar CPU

• Livelock: hilo A realiza acción que causa que B realice otra acción que a su vez vuelve a causar la acción de A: se interbloquean ocupando la CPU

• Stravation (inanición): otros hilos “hambrientos” ocupan el recurso (o CPU) que nuestro hilo necesita para seguir funcionando



Mecanismos de alto nivel

• Implementaciones que proporciona Java para facilitar la programación con concurrencia

– Interfaz Lock– Colecciones concurrentes– Variables atómicas– Ejecutores y pools– Otros muchos en el paquete java.util.concurrent



La interfaz Lock

• En lugar de synchronized:synchronized(this){

// acceder al recurso

}

• Adquirir un objeto Lock y después liberarloLock l = ...;l.lock();try { // acceder al recurso protegido por l} finally { l.unlock();}



La interfaz Lock

• Añade algunos métodos más versátiles– tryLock( ) : rechaza darnos el lock si éste no está

disponible en el instante o bien tras un tiempo de espera especificado. Permite evitar deadlocks.

– lockInterruptibly( ) : rechaza darnos el lock si otro hilo envía una interrupción antes de que el lock haya sido adquirido

– Da soporte a un mecanismo de wait/notify a través de objetos Condition que dejarían el hilo a la espera de que se cumpla la condición



Lock y Conditionclass BufferLimitado { final Lock lock = new ReentrantLock(); //Dos condiciones para notificar sólo a los hilos //que deban hacer put o take, respectivamente final Condition notFull = lock.newCondition(); final Condition notEmpty = lock.newCondition();

final Object[] items = new Object[100]; int putptr, takeptr, count;

public void put(Object x) throws InterruptedException { lock.lock(); try { while (count == items.length) notFull.await(); items[putptr] = x; if (++putptr == items.length) putptr = 0; ++count; notEmpty.signal(); } finally { lock.unlock(); } }

public Object take() throws InterruptedException { lock.lock(); try { while (count == 0) notEmpty.await(); Object x = items[takeptr]; if (++takeptr == items.length) takeptr = 0; --count; notFull.signal(); return x; } finally { lock.unlock(); } } }



Colecciones concurrentes

• La colección Vector garantiza el acceso sincronizado

• El paquete java.util.concurrent contiene colecciones con un soporte más avanzado para concurrencia

– BlockingQueue: FIFO con tiempo de espera máximo cuando añadimos y no cabe, o quitamos y no hay.

– ConcurrentMap: subinterfaz de Map que define operaciones atómicas útiles (quitar una clave valor sólo si la clave está presente, etc).

– ConcurrentNavigableMap para coincidencias aproximadas



Variables atómicas

• Para no tener que sincronizar el acceso a variables, contamos con versiones atómicas de éstas:

– AtomicBoolean

– AtomicInteger

– AtomicIntegerArray

– AtomicIntegerFieldUpdater<T>

– AtomicLong

– AtomicLongArray

– AtomicLongFieldUpdater<T>

– AtomicMarkableReference<V>

– AtomicReference<V>

– AtomicReferenceArray<E>

– AtomicReferenceFieldUpdater<T,V>

– AtomicStampedReference<V>



Variables atómicas

• Ejemplo: synchronized / variable atómicaclass ContadorSincronizado { private int c = 0; public synchronized void increment() { c++; } public synchronized void decrement() { c--; } public synchronized int value() { return c; } }

import java.util.concurrent.atomic.AtomicInteger; class ContadorAtomic { private AtomicInteger c = new AtomicInteger(0); public void increment() { c.incrementAndGet(); } public void decrement() { c.decrementAndGet(); } public int value() { return c.get(); } }



Ejecutores

• Se separa la gestión de la ejecución de los hilos en clases especializadas

• Interfaz Executor: obliga a implementar el método execute(Runnable r)

• En lugar de iniciar el hilo con (new Thread(r)).start( );lo iniciaremos con

e.execute(r);

teniendo: Runnable r; Executor e;



ExecutorService

• Subinterfaz de Executor

• Añade el método Future submit( objeto ) que acepta objetos Runnable y Callable, que permiten devolver un valor al finalizar la tarea.

• submit( ) devuelve objetos Future que permiten obtener el estado de la tarea a ejecutar y devuelven un resultado en el caso de Callable.



ScheduledExecutorService

• Subinterfaz de ExecutorService

• Añade el método schedule( ) que ejecuta un Runnable o Callable después de un tiempo especificado

• También añade scheduleAtFixedRate( ) y scheduleWithFixedDelay( ) para tareas periódicas



Pools de hilos

• Uno o varios “worker thread” ejecutan los métodos run( ) de distintos Runnable / Callable, pero en el mismo hilo.

• Se ahorra la sobrecarga de creación y destrucción de hilos en la que interviene reserva y liberación de memoria

• Creación del pool – distintas maneras:– Método estático newFixedThreadPool(n)– Instancia de ThreadPoolExecutor o de

ScheduledThreadPoolExecutor.



Instancia de ThreadPoolExecutor

//Al principio del fichero://import java.util.concurrent.*;//import java.util.*;

int poolSize = 2;int maxPoolSize = 2;long keepAliveTime = 10;

final ArrayBlockingQueue<Runnable> queue = new ArrayBlockingQueue<Runnable>(5);

ThreadPoolExecutor threadPool = new ThreadPoolExecutor(poolSize, maxPoolSize, keepAliveTime, TimeUnit.SECONDS, queue); Runnable myTasks[3] = ....; // y le asignamos tareas

//Poner a ejecutar dos tareas y una que quedará en cola:for(int i=0; i<3; i++){ threadPool.execute(task); System.out.println("Tareas:" + queue.size());} //Encolar otra tarea más que declaramos aquí mismo: threadPool.execute( new Runnable() { public void run() { for (int i = 0; i < 10; i++) { try { System.out.println("i = " + i); Thread.sleep(1000); } catch (InterruptedException ie){ } } } }); //Ejecuta las tareas que queden pero ya no acepta nuevas:threadPool.shutdown();



Sobrecarga de ThreadPoolExecutorclass PausableThreadPoolExecutor extends ThreadPoolExecutor {

private boolean isPaused; private ReentrantLock pauseLock = new ReentrantLock(); private Condition unpaused = pauseLock.newCondition(); //Sobrecargamos el método: protected void beforeExecute(Thread t, Runnable r) { super.beforeExecute(t, r); pauseLock.lock(); //Sección sincronizada try { while (isPaused) unpaused.await(); //Bloquearlo } catch (InterruptedException ie) { t.interrupt(); } finally { pauseLock.unlock(); } }

//Nota: para pausar cada hilo el programador debe //implementar la lógica necesaria

//Método nuevo: public void pause() { pauseLock.lock(); //Sección sincronizada try { isPaused = true; } finally { pauseLock.unlock(); } } //Método nuevo: public void resume() { pauseLock.lock(); //Sección sincronizada try { isPaused = false; unpaused.signalAll(); //Desbloquea hilos bloqueados } finally { pauseLock.unlock(); } }}



¿Preguntas...?

Presentación de PowerPointexpertojava.ua.es/dadm/restringido/java/traspas/sesion05-traspas.pdf ·...

Documents

Transcript of Presentación de PowerPointexpertojava.ua.es/dadm/restringido/java/traspas/sesion05-traspas.pdf ·...