Curso de Programación en Java - Laboratorio SS.OO...

1 mayo de 2010 Curso de programación en Java

Curso de Programación en Java


Índice •  Excepciones •  Genéricos •  Colecciones

–  Interfaces: •  Collection, Set, List, Queue, Map, SortedSet, SortedMap

–  Implementaciones •  HashSet, ArrayList, LinkedList, HashMap, TreeSet, TreeMap

–  Algoritmos

•  Concurrencia –  Threads


Excepciones


Introducción (I)

•  La idea es separar el funcionamiento normal de un programa de la gestión de los errores.

•  Si algo va mal: – División por cero. – No hay más memoria. – No existe el fichero deseado.

•  Se lanza una excepción que HAY que tratar.


Introducción (II)

•  El tratamiento de la excepción será distinto para cada caso, separando claramente lo que se debe hacer en cada caso

•  Si se puede recuperar del error continuará la ejecución normalmente, sino finaliza – Si no existe el fichero, pide otro nombre (bucle) – Si entrada en formato incorrecto, pide otro dato.


Sintaxis

•  Se apoya en –  try {...}: Abarca el programa normal. Si todo va

bien será lo que ejecute. –  throw exception: Cuando algo va mal nos

permite lanzar una excepción para indicarlo. –  catch (class exception) {…}: Nos permite tratar

un tipo de excepción. Habrá un catch por cada tipo posible.

–  finally {…} Siempre se ejecuta, va al final.


Ejemplo try { // Codigo normal ... if (algo mal) throw excep; // Si fue mal esto no ejecutaria ...

} catch (ArithmeticException e){...} // Excp. Aritm catch (InputMismatchException e) // Excp. formato catch (MyException) {...} //”mis” excep. finally {...} // Siempre se ejecuta

•  Este esquema puede repetir varias veces, consecutivas o en un bucle. Finalizado no debe haber errores por tratar


Paso de Excepciones entre funciones (I)

•  Si una función no captura una excepción está va a la función que la invocó, que saltará al “catch” correspondiente, así hasta el main

•  Si ninguna la captura se da una terminación anómala

Exception in thread "main" java.lang.ArithmeticException: / by zero


Paso de Excepciones entre funciones (II)

•  Para indicar las excepciones que una función puede lanzar se ponen explicitamente: throws

int pop () throws EmptyStackException {...}

•  Una función, dentro del catch, puede lanzar otra excepción (p.e. si no sabe tratar la 1ª)

•  E incluso relanzar la misma: throw e;


Definir excepciones •  Hay algunas predefinidas:

–  NoSuchFieldException, NoSuchMethodException, NullPointerException , IllegalArgumentException, ArrayIndexOutOfBoundsException, IOException, ClassNotFoundException

•  Incluso podemos definir nuestras Excep. class EmptyStackException extends Exception { EmptyStackException(String s) { super(s); } }


Errores

•  Similar idea a las excepciones, pero son fallos que

no están pensados para capturarse y tratarse: –  OutOfMemoryError, VirtualMachineError

•  Se supone que son irrecuperables •  En cambio todas las excepciones deberían

capturarse para salir de forma “limpia”


Aserciones (I)

•  Similar idea a las excepciones, pero son detectan fallos del programador.

•  Toda función necesita que se cumplan unas premisas a la entrada (precondiciones) y deja el estado en un modo conocido (postcondiciones)

•  Si no se cumplen algo ha ido mal •  Se activan en desarrollo y depuración, para no

penalizar las ejecuciones “normales”: java –ea ejecutable


Aserciones (II)

•  No están pensadas para ser tratadas (generan un AssertionError)

•  No se tratan porque al ser errores de programación no deberían darse y si se dan no está claro como recuperarse

assert(b!=0):“El divisor no puede ser cero";

•  Genera: Exception in thread "main" AssertionError: El divisor no puede ser cero


Genéricos o Prototipos


Introducción (I) •  Hay ciertos aspectos y características que son comunes

a muchas clases. •  Por ejemplo, estructuras de datos (pilas, listas, colas,

árboles,...) o algoritmos (ordenar, invertir, sustituir) que pueden aplicarse a cualquier clase, no varía su significado.

•  Podemos tener una pila de enteros, de platos, de strings o de coches.

•  Podemos ordenar enteros, reales, complejos, strings,...

Templates


Introducción (II) •  Ejemplo: PILA. Definamos una pila de enteros:

Generics


Introducción (III) •  La idea es programarlo una vez y no volver a tener que

hacerlo •  Aumenta la productividad ya que se reutiliza el código •  Aumenta la calidad ya que se usa código “probado” •  Permite centrarse en los aspectos importantes de

nuestro programa •  Debería incrementar la velocidad, una única

implementación pero de calidad •  ¡¡¡Otros ya lo han implementado por nosotros!!!

Generics


Introducción (IV) •  Además el compilador detecta errores que de otro

modo no podría: Código más legible y robusto •  Sea una caja para guardar objetos en general: public class Box {

private Object object;

public void add(Object object)

{ this.object = object; }

public Object get()

{ return object; } }

Generics


Introducción (V) •  A la hora de usarla podemos tener problemas: // ONLY place Integer into this box! Box

integerBox = new Box(); // Cast???

Integer someInt =(Integer) integerBox.get();

// MAL!!!

integerBox.add("10"); // String!!!!

•  Esta mal pero el compilador no lo dice y luego se generará una “java.lang.ClassCastException: “

Generics


Generics (I) •  Volvamos con la pila de enteros ¿Qué sucede si

ahora deseamos una pila de caracteres? •  Necesitamos rehacer todo. Es absurdo. •  Para esto están los prototipos o generics. Se

aplican a clases, constructores, métodos,... •  Se deja el tipo a utilizar como un argumento que

luego se especificará. •  No se genera una clase para cada nuevo tipo,

todas son la misma.

Generics

Generics (II) // Sustituimos Object por T

public class Box<T> { private T t; // T is "Type" public void add(T t) { this.t = t; } public T get() { return t; } }

•  T es un tipo “formal” que luego será sustituido por el tipo “real”. T se puede usar casi como cualquier tipo normal

Generics

Generics (III) •  A la hora de usarla se indica el tipo: Box<Integer> integerBox = new Box<Integer>();

•  Beneficios claros: // Sin Cast!!!

Integer someInt = integerBox.get(); // El compilador nos avisa que está mal!!!

integerBox.add("10"); // String

•  El compilador entiende que queremos hacer y nos da mejor soporte.

Generics

Generics (IV) •  Se pueden usar también argumentos de tipo en métodos y

constructores. En la clase Box: public void inspect(U u){

System.out.println("T: " + t.getClass().getName());

System.out.println("U: " +

u.getClass().getName()); } •  También se puede usar más de un argumento de tipo: T, U •  Al usarlo: integerBox.inspect("some text"); T: java.lang.Integer

U: java.lang.String

Generics


Generics (V) •  Normalmente en mayúsculas (para distinguirlos de los

parámetros normales) y cortos (una letra): – E - Element – K - Key – N - Number – T - Type – V - Value – S,U,V etc. - 2nd, 3rd, 4th types

Generics

Generics (VI) •  También con métodos estáticos. En la clase Box: public static void fillBoxes(U u, List<Box> boxes) {

for (Box box : boxes) { box.add(u); }

}

•  Al usarlo: Crayon red = ...; List<Box<Crayon>> crayonBoxes = ...;

Box.<Crayon>fillBoxes(red, crayonBoxes);

Box.fillBoxes(red, crayonBoxes); // Es igual.

Generics

Tipos acotados

•  Para restringir el tipo de dato que se pueda usar (bounded type parameters) se usa extends seguido de un tipo (o interfaz) que marca el límite superior public void inspect(U u) { …}

•  U debe ser un subclase de Number, sino no compila. •  Se pueden combinar varios:



Generics

Subtipos

•  Integer y Double son subtipos de Number, pero Box<Integer> y Box<Double> no de Box<Number>

Box<Number> b = new Box<Number>();

b.add(new Integer(10)); // OK

b.add(new Double(10.1)); // OK

public void boxEmpty(Box<Number> b){ … } Box.boxEmpty(new Box<Integer>()); //NO!!!

Box.boxEmpty(new Box<Double>()); //NO!!!

Generics

Comodines (Wildcards)

•  Para solucionar esto está los comodines “?”, que indica tipo desconocido. Se suele usar junto a modo acotado.

•  Caja de tipo desconocido subtipo de Number: Box<? extends Number> b;

public void boxEmpty(Box<?> b){} //También!! b = new Box<Integer>(); //Si

Box.boxEmpty(new Box<String>()); // Si

b.add(new Integer()); // NO b tipo real desc.

Generics

Borrado del tipo (I) •  Como se ha dicho, no se genera un clase para cada

tipo, el compilador borra los argumentos de tipo y sólo hay una clase: Box<String> pasa a Box.

•  No se puede saber el tipo de una clase genérica durante la ejecución (Box es de raw type).

if (item instanceof E) {…} // error

E item2 = new E(); // error

E[] iArray = new E[10]; // error

E obj = (E)new Object(); //Unchecked cast war

Generics


Borrado del tipo (II) •  Los raw types se pueden usar, pero generan warnings

ya que el compilador no puede chequear los tipos. •  Es legal usarlo por compatibilidad con código antiguo •  Si se usan mal generarán una excepción en tiempo de

ejecución •  Al generar las clases genéricas una única clase, no se

puede usar el tipo formal en variables estáticas (debe haber una instancia para conocer el tipo real)

Generics

Borrado del tipo (III) •  Una solución para E item2 = new E(); es usar

literales de tipo clase. •  Ahora java.lang.Class<T> es genérico y su

método newInstance() devuelve T public static <T> void select(Class<T> c, String sqlStatement){ for (/* Iterate over jdbc results. */ ) { T item = c.newInstance(); result.add(item); } return result; }

Generics

Tipos Expandidos (I) •  Hay casos en que queremos mitigar cierta restricción de tipos,

por ejemplo, para llamar a un método de una clase padre que admite algo menos restrictivo. Ejemplo sencillo:

interface Sink<T> { flush(T t); } public static <T> T writeAll(Collection<T> coll, Sink<T> snk) { T last; for (T t : coll) { last = t; snk.flush(last);

} return last; }

Generics

Tipos Expandidos (II) Sink<Object> s;

Collection<String> cs;

String str = writeAll(cs, s); // Illegal •  Tanto String como Object no encajan. Alternativa public static <T>

T writeAll(Collection<? extends T>, Sink<T>) {...} ...

// Call is OK, but wrong return type.

String str = writeAll(cs, s);

Generics

Tipos Expandidos (III) •  La solución es usar super. Es la inversa de extends, indica un

supertipo de otro, Sink<? super T> •  Es decir, recibe algo que es supertipo de T. En este caso será un

Objeto, que es supertipo de String: public static <T>

T writeAll(Collection<T> coll, Sink<? super T> snk) { ... }

Sink<Object> s;

Collection<String> cs;

String str = writeAll(cs, s); // Yes!

Generics


Colecciones (Biblioteca)


Introducción (I) •  Como ya se ha dicho, hay estructuras de datos (pilas,

listas, colas, árboles, hash,...) o algoritmos (ordenar, invertir, sustituir) que pueden aplicarse a muchas clases.

•  Apoyándose en los generics, se ha construido en java una biblioteca de estructuras de datos y algoritmos, muy útil.

•  ¡¡¡Otros ya lo han implementado por nosotros!!! •  Las colecciones agrupan elementos (contenedores).

Permiten añadir, borrar y manipularlos fácilmente.

Collections


Introducción (II) •  Aumenta la productividad ya que se reutiliza el código •  Aumenta la calidad ya que se usa código “probado” •  Permite centrarse en los aspectos importantes de

nuestro programa •  Aumenta la velocidad, una implementación de calidad •  La biblioteca está formada por:

–  Interfaces, que definen como debe comportarse un TAD –  Implementaciones de estos interfaces –  Algoritmo para trabajar con estos TAD

•  Deben usarse los interfaces, sin entrar en detalles de la implementación concreta.

Collections

Interfaces (I)

•  Todos estos contenedores son genéricos, pueden trabajar con cualquier tipo de objeto:

List<String> listaNombres;

•  Cada interfaz tiene varias implementaciones que le dan soporte, el usuario elige la que más le conviene.

•  Debe usarse a través de la interfaz, no la implementación

Collections

Collections (I) public interface Collection<E> extends Iterable<E> { // Basic operations (a nivel de elementos) int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); boolean remove(Object element); Iterator<E> iterator(); // Bulk operations (a nivel de la Colección) boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); // Array operations Object[] toArray(); <T> T[] toArray(T[] a); }

Interfaces

Collections (II) Interfaces

•  Representan grupos de objetos o elementos •  Si se modifica devuelve true, sino false. •  Dos formas de recorrerlos:

–  for-each –  Iteradores:

public interface Iterator<E> { boolean hasNext(); E next(); void remove(); }

Collections (III) Interfaces

•  for-each for (Object o : collection)

System.out.println(o); •  Iteradores: c colección de E’s for(Iterator<E>it=c.iterator();it.hasNext(); )

if (!cond(it.next()))

it.remove();


Collections (IV) Interfaces

•  Transformaciones a arrays para antiguas APIs Object[] a = c.toArray(); // c collection of Strings

String[] a = c.toArray(new String[0]);


Set (I) Interfaces

•  Representa Conjuntos. •  No permite elementos duplicados •  Mismos métodos que collection •  Tres implementaciones de propósito general

–  HashSet: rápido, no guarda el orden. La usual. –  TreeSet: más lento, ordena los elementos –  LinkedHashSet: guarda el orden en que se insertaron

•  Permite operaciones de conjuntos: unión (addAll), intersección (retainAll), subconjuntos (containAll),…

Set (II) Interfaces

•  No usar la implementación: Set<String> uniques = new HashSet<String>();

Set<String> dups = new HashSet<String>();

for (String a : args)

if (!uniques.add(a))

dups.add(a);

// Destructive set-difference

uniques.removeAll(dups);

•  Con cambiar HashSet por TreeSet ya estaría ordenado!!


List (I) Interfaces

•  Es una secuencia ordenada, admite elementos duplicados •  Se puede acceder al elemento i-esimo (get y set) •  Se puede insertar/borrar a una posición add/remove •  Se puede buscar un elemento (indexOf) •  Se pueden obtener sublistas •  El iterador se ha mejorado y es bidireccional. El

constructor admite la posición en la que empezar •  Dos implementaciones generales: ArrayList, LinkedList

List (II) Interfaces

public interface List<E> extends Collection<E>{

// Positional access

E get(int index);

E set(int index, E element);

boolean add(E element); // añade al final

void add(int index, E element);

E remove(int index);

boolean addAll(int index,Collection<? extends E>c);

int indexOf(Object o); // Search

int lastIndexOf(Object o); // Search

ListIterator<E> listIterator(); // Iteration

ListIterator<E> listIterator(int index);//Iteration

// Range-view [from,to), from:incl, to:excl

List<E> subList(int from, int to); }

ListIterator Interfaces

public interface ListIterator<E> extends Iterator<E> {

boolean hasNext();

E next();

boolean hasPrevious();

E previous();

int nextIndex();

int previousIndex();

void remove();

void set(E e);

void add(E e); }


Queue (I) Interfaces

•  Representan colas, por ejemplo, de trabajos (para la impresora, cpu o similar)

•  Pueden ser FIFO o LIFO. Hay colas con prioridades. •  Existen versiones que, en situaciones críticas, lanzan

excepciones o devuelven un valor especial, null, si pila vacía, llena: –  Add-offer, remove-poll, element-peek

•  Dos implementaciones generales: LinkedList, PriorityQueue

Queue (II) Interfaces

public interface Queue<E> extends Collection<E> {

E element(); // no lo quita

boolean offer(E e); //add al final

E peek(); // no lo quita

E poll(); // remove al principio

E remove(); // remove al principio

}

Map (I) Interfaces

•  Asocia a cada clave un valor. No puede haber claves repetidas. Es un conjunto de parejas (clave, valor)

•  Un ejemplo, un listín telefónico o una agenda •  Tres implementaciones de propósito general:

–  HashMap, TreeMap, LinkedHashMap, análogo a Set •  El valor puede ser cualquier cosa, inclusa una lista: Map<String, List<String>> map =

new HashMap<String, List<String>>();

Map (II) Interfaces

public interface Map<K,V> {// Basic operations

V put(K key, V value);

V get(Object key);

V remove(Object key);

boolean containsKey(Object key);

boolean containsValue(Object value);

int size();

boolean isEmpty();

// Bulk operations

void putAll(Map<? extends K, ? extends V> m);

void clear();

// Collection Views (muy potente!!!)

public Set<K> keySet();

public Collection<V> values();

public Set<Map.Entry<K,V>> entrySet(); }

Map (III) Interfaces

// Interface for entrySet elements

public interface Entry {

K getKey();

V getValue();

V setValue(V value);

}

•  Ejemplo for (KeyType key : map.keySet())

System.out.println(key);

for (Map.Entry<KeyType, ValType> e : m.entrySet()) System.out.println(e.getKey() + ": " + e.getValue());


SortedSet (I) Interfaces

•  Conjunto ordenado según un orden natural o el criterio que proporcione la clase de los objetos guardados

•  Incluye subconjuntos (rangos), acceso al principio y final, al comparador. Los rangos son semi-abiertos

// Borrar palabras que empiezan por ‘f’

dictionary.subSet("f", "g").clear();

•  Una implementación general: TreeSet

SortedSet (II) Interfaces

public interface SortedSet<E> extends Set<E> {

// Range-view [from,to) from:incl, to:excl

SortedSet<E> subSet(E fromElement, E toElement);

SortedSet<E> headSet(E toElement);

SortedSet<E> tailSet(E fromElement);

// Endpoints

E first();

E last();

// Comparator access

Comparator<? super E> comparator();

}


SortedMap (I) Interfaces

•  Diccionario ordenado por las claves según un orden natural o el criterio que proporcione la clase de los objetos guardados

•  Incluye subconjuntos (rangos), acceso al principio y final, al comparador. Los rangos son semi-abiertos

•  Una implementación general: TreeMap

SortedMap (II) Interfaces

public interface SortedMap<K, V> extends Map<K, V>{

Comparator<? super K> comparator();

SortedMap<K, V> subMap(K fromKey, K toKey);

SortedMap<K, V> headMap(K toKey);

SortedMap<K, V> tailMap(K fromKey);

K firstKey();

K lastKey();

}


Orden (I) Interfaces

•  Ciertas clases admiten un orden natural, como los números, los Strings, las fechas (Date), ficheros o los caracteres

•  En otros casos debe definirse para cada clase. En personas puede ser según Apellidos y luego el nombre

•  En empleados puede ser la fecha de contratación •  Para usar SortedSet y SortedMap los objetos deben

poderse comparar, deben implementar Comparable y su único método compareTo(object o)

Orden (II) Interfaces

•  int compareTo(object o) compara el objeto recibido por parámetro y el actual y devuelve negativo, cero o positivo si el parámetro es menor, igual o mayor que el actual (debe establecer un Orden Total)

•  Una alternativa a Comparable es Comparator<T> que tiene int compare(T obj1, T obj2) y funciona similar.

•  Se usa para clases que no implementan Comparable •  Se pasa al Sort: <T> void sort(List<T> list, Comparator<? super T> c)


Introducción Implementaciones

•  Existen múltiples implementaciones que proporcionan la funcionalidad de cada interfaz.

•  La mayoría son generales, las hay especificas buscando características concretas. Y los usuarios pueden hacer las suyas a partir de implementaciones abstractas.

•  Otras son sincronizadas para permitir concurrencia. •  Otras son mini-implementaciones, muy eficientes. •  No debe hacerse el programa dependiente de la

implementación elegida.


Set Implementaciones

•  Set: Generales: –  HashSet: rápida, no guarda el orden. La usual. Crece según

necesidad. Se puede indicar tamaño inicial –  TreeSet: más lenta, ordena los elementos –  LinkedHashSet: guarda el orden en que se insertaron.

También se puede indicar tamaño inicial.

•  Set: Específicas: –  EnumSet: Para enumerados, muy eficiente (bit-vector) –  CopyOnWriteArraySet: para conjuntos que se leen mucho y

se escriben raramente. Todas las operaciones de escritura se hacen copiandolo, seguro con alta concurrencia.


List Implementaciones

•  List: Generales: –  ArrayList: rápida, tipo vector. Si inserta mucho al principio

o se borran elemento, va mal. Puede indicarse tamaño inicial –  LinkedList: guarda el orden en que se insertaron.

Implementa también Queue. •  List: Específicas:

–  CopyOnWriteArraySet: para listas que se leen mucho y se escriben raramente. Todas las operaciones de escritura se hacen copiandolo, seguro con alta concurrencia.

–  Si necesita concurrencia, usar Vector.


Map Implementaciones

•  Map: Generales: –  HashMap: rápida, tipo vector. Si inserta mucho al principio o

se borran elemento, va mal. Puede indicarse tamaño inicial –  TreeMap: es ordenado siguiendo la clave. –  LinkedHashMap: guarda el orden de inserción o según la clave

•  Map: Específicas: –  EnumMap: Para claves enumeradas (es un array) –  WeakHashMap. Guarda referencias ‘debiles’, (sólo si se usan) –  IdentityHashMap. Se basa en “identidad” (objetos cambiantes). –  ConcurrentHashMap. Para el interfaz ConcurrentMap


Queue Implementaciones

•  Queue: Generales: –  LinkedList: rápida. –  PriorityQueue: Colas con prioridad.

•  Queue: Concurrentes, implementan BlockingQueue –  LinkedBlockingQueue. FIFO y acotada, nodos enlazados –  ArrayBlockingQueue. FIFO y acotada, un array –  PriorityBlockingQueue. Cola basada en prioridades no acotada –  DelayQueue. Cola de planificación basada en tiempo –  SynchronousQueue

Wrapper Implementations Implementaciones

•  Añaden funcionalidad extra a ciertas implementaciones •  Synchronization wrappers. Añaden sincronización. Para

Collection, Set, List, Queue, Map, SortedSet, SortedMap •  Se crean: Map<KeyType, ValType> m = Collections.

synchronizedMap (new HashMap<KeyType, ValType>());

•  Todos los accesos deben accerse a través de esa variable •  Los iteradores deben protegerse (son varios accesos) Set<KeyType> s = m.keySet();

synchronized(m) { // Synchronizing on m, not s!

while (KeyType k : s) foo(k); }

•  Unmodifiable wrappers, para sólo lecturas. Para Collection, Set, List, Queue, Map, SortedSet, SortedMap


Mini Implementations Implementaciones

•  Array.asList. Da una vista del array como una lista. No puede cambiar de tamaño. Para lista de tamaño fijo.

•  Collections.nCopies. Una lista inmutable que contiene n copias de un mismo elmento. Para inicializaciones.

•  Collections.singleton. Un conjunto con un único elemento •  emptySet, emptyList y emptyMap de Collections. Vacías.


Introducción Algoritmos

•  Son métodos ‘estáticos’ y genéricos de Collections. •  La mayoría operan sobre listas. •  Sort. Ordena según orden natural o orden dado •  Shuffle. Baraja, usa Random. •  Manipulación de datos: reverse, fill, copy, swap, addAll •  binarySearch. Búsqueda. •  Sobre Collection: frecuency, disjoint, min, max


Abstract Implementations Implementaciones

•  Esqueletos de implementaciones para facilitar a los usuarios sus propias implementaciones.

•  No suele ser necesario, siempre hay alguna implementación que nos viene bien.

•  Posibles razones: –  Implementar persistencia –  Añadir funcionalidad –  Específicas para ciertas aplicaciones

•  Hay versiones abstractas de las seis interfaces •  Basta con implementar los métodos abstractos. Fácil.


Concurrencia (Threads)


Introducción •  Los computadores hacen varias cosas a la vez

–  Navegador, editores, procesador de textos, hojas de cálculo, compilador,…

•  Hoy en día, con varios núcleos, más aún. •  Cada ejecución de un programa es un proceso •  Un proceso es autocontenido, con todos los recursos

que necesita para poder ejecutar. •  Los procesos pueden cooperar usando IPC •  Java permite lanzar nuevos procesos (ProcessBuilder)

Concurrencia


Threads (I) •  Un proceso puede tener varios threads •  Estos threads comparten los recursos del proceso

(memoria, ficheros,…), son más ligeros y eficientes •  Java permite lanzar nuevos threads. Dos vías:

–  Implementar Runnable y su método Run: (new Thread(new ClassRunnable())).start(); –  Extender Thread (también Run): (new ClassThread()).start();

•  Además de crearlo debe lanzarse (start)

Concurrencia


Threads (II) •  Extender Thread es más sencillo y proporciona

métodos para conocer y manipular el thread, pero no puede heredar de otra clase.

•  Runnable es más flexible y permite además heredar de otra clase. Permite separar la tarea a realizar del thread que lo realizará

•  Al usar Thread surgen posible Excepciones

Concurrencia


Funcionalidad de Threads •  sleep() nos permite suspende un thread (miliseg) •  Puede ser interrumpido por otro, interrupt() •  Se genera una Excepción (InterruptedException) •  Esa interrupción le indica que deje de hacer

‘algo’ para pasar a hacer otra cosa. •  Si no estaba suspendido puede preguntar por

interrupted() para saber si alguien le interrumpió •  Se puede esperar por un thread, join().

Concurrencia


Sincronización (I) •  Los threads se comunican fácilmente, comparten

toda la información (ven la misma memoria) •  Pueden surgir problemas si no se coordinan al

acceder a la información: Errores •  Dos leen una variable A, la incrementan y la

guardan. ¡¡¡Solo se ha incrementado en UNO!!! •  Java proporciona synchronized para evitarlo •  Cada objeto (y clase) tiene una “llave” o lock

Concurrencia


Sincronización (II) •  Una clase puede tener métodos sincronizados synchronized void metodo1() { …} synchronized void metodo2() { …}

•  No se pueden ejecutar a la vez invocaciones a métodos sincronizados de un mismo objeto

•  Si un thread ya está actualizando este objeto, cualquier otro thread deberá esperar a que termine el método que está ejecutando para poder ejecutar otro método sincronizado

•  Se implementa con cerrojos (lock) en cada objeto

Concurrencia


Sincronización (III) •  Un thread debe adquirir este cerrojo para modificar el

objeto y lo liberar al final. •  Mientras nadie puede coger el cerrojo, esperan. •  Se pueden sincronizar sentencias: synchronized(this) {…} // especifica el obj.

•  Un thread puede adquirir un cerrojo que ya tiene, puede llamar a otros métodos sincronizados.

•  Si un thread 1 intentar adquirir el cerrojo de un objeto B desde un objeto A y otro thread 2 intenta adquirir el cerrojo de A desde B, se produce un interbloqueo.

Concurrencia


Coordinación •  A veces un thread debe esperar que otro calcule algo: while (!data.isReady()) { “nada”; }

•  La cpu está ocupada para nada!!!! •  Se puede decir que espere (wait). Libera la cpu. while (!data.isReady()) { wait(); } •  La espera puede ser interrumpida •  El otro thread le avisa con notify() o notifyAll() •  Se debe usar en métodos sincronizados. Libera el

cerrojo y luego lo vuelve a coger para examinar la condición.

Concurrencia


Cerrojos (intefaz lock) •  Se pueden crear y manipular directamente. •  Solo un thread puede tener un cerrojo •  Tiene una condition asociada para soportar wait,

notify y notifyAll •  Tiene: lock(), unlock() y tryLock()

–  Lock: coger la llave –  Unlock: dejar la llave –  Trylock: Si puedo cojo la llave, si no hago otra cosa

Concurrencia


Ejecutores (intefaz Executor) •  Separan la tarea (task) a hacer del thread. •  (new Thread(r)).start(); pasa a e.execute(r); •  Si hay threads disponibles pone a ejecutar “r” (no

crea el thread). Si no los hay, pone “r” como una tarea pendiente de ejecutar.

•  Con ExecutorService submit(), además de Runnable admite Callable (devuelve un valor)

•  Con ScheduledExecutorService se añade la posibilidad de indicar cuando ejecutará

Concurrencia


Listas de threads (pool) •  Da la opción de reutilizar los threads. Cuando

acaban no se destruyen, se dejan por si luego hay una tarea que necesita ser ejecutada. Más rápido

•  Limita los recursos consumidos. •  Los hay con un número de threads fijo

(newFixedThreadPool), variable (newCachedThreadPool) o una tarea cada vez (newSingleThreadExecutor)

Concurrencia


Sincronización adicional •  Bastante estructuras de datos de Collections

tienen implementaciones concurrentes: BlockingQueue, ConcurrentMap, ConcurrentNavigableMap

•  Para facilitar el acceso a variable compartidas están los Atomic: AtomicInteger, AtomicBoolean, AtomicLong, AtomicReference

Concurrencia

Curso de Programación en Java - Laboratorio SS.OO...

Documents

Transcript of Curso de Programación en Java - Laboratorio SS.OO...