Lenguaje Java. Sesión 5: Hilos. Experto Universitario en Desarrollo de Aplicaciones para Dispositivos Móviles

Transcripción

1 Lenguaje Java Sesión 5: 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 Java Hilos-2

3 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)

4 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

5 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 hilo Thread t = new Thread(new MiHilo()); t.start();

6 Implementar Runnable Implementar Runnable public class MiHilo implements Runnable { public void run() { // Codigo de la tarea a ejecutar en el hilo Instanciar el hilo Thread t = new Thread(new MiHilo()); t.start();

7 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

8 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

9 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

10 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

11 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.

12 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

13 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() ");

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

15 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

16 Bloques vigilados En lugar de esperar iterativamente (que ocupa la CPU): 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"); Bloquear el hilo y esperar una notificación por parte de otro. public synchronized bloquevigilado() { while(!condicion) { try { wait(); // desocupa la CPU catch (InterruptedException e) { System.out.println("La condición se ha cumplido");

17 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

18 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");

19 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");

20 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 synchronized String take() { // 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 synchronized void put(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();

21 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

22 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

23 La interfaz Lock En lugar de synchronized: synchronized(this){ // acceder al recurso Adquirir un objeto Lock y después liberarlo Lock l =...; l.lock(); try { // acceder al recurso protegido por l finally { l.unlock();

24 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

25 Lock y Condition class 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();

26 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

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

28 Variables atómicas Ejemplo: synchronized / variable atómica class 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();

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

30 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.

31 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

32 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.

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

34 Sobrecarga de ThreadPoolExecutor class 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();

35 Preguntas...?