curso de programación en java - laboratorio ss.oo...
Post on 05-Oct-2018
222 Views
Preview:
TRANSCRIPT
1 mayo de 2010 Curso de programación en Java
Curso de Programación en Java
2 mayo de 2010 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
3 mayo de 2010 Curso de programación en Java
Excepciones
4 mayo de 2010 Curso de programación en Java
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.
5 mayo de 2010 Curso de programación en Java
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.
6 mayo de 2010 Curso de programación en Java
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.
7 mayo de 2010 Curso de programación en Java
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
8 mayo de 2010 Curso de programación en Java
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
9 mayo de 2010 Curso de programación en Java
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;
10 mayo de 2010 Curso de programación en Java
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); } }
11 mayo de 2010 Curso de programación en Java
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”
12 mayo de 2010 Curso de programación en Java
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
13 mayo de 2010 Curso de programación en Java
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
14 mayo de 2010 Curso de programación en Java
Genéricos o Prototipos
15 mayo de 2010 Curso de programación en Java
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
16 mayo de 2010 Curso de programación en Java
Introducción (II) • Ejemplo: PILA. Definamos una pila de enteros:
Generics
17 mayo de 2010 Curso de programación en Java
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
18 mayo de 2010 Curso de programación en Java
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
19 mayo de 2010 Curso de programación en Java
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
20 mayo de 2010 Curso de programación en Java
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
21 mayo de 2010 Curso de programación en Java
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
22 mayo de 2010 Curso de programación en Java
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
23 mayo de 2010 Curso de programación en Java
Generics (IV) • Se pueden usar también argumentos de tipo en métodos y
constructores. En la clase Box: public <U> 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
24 mayo de 2010 Curso de programación en Java
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
25 mayo de 2010 Curso de programación en Java
Generics (VI) • También con métodos estáticos. En la clase Box: public static <U> void fillBoxes(U u, List<Box<U>> boxes) {
for (Box<U> 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
26 mayo de 2010 Curso de programación en Java
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 <U extends Number> void inspect(U u) { …}
• U debe ser un subclase de Number, sino no compila. • Se pueden combinar varios:
<U extends Number & MyInterface>
Generics
27 mayo de 2010 Curso de programación en Java
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
28 mayo de 2010 Curso de programación en Java
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
29 mayo de 2010 Curso de programación en Java
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
30 mayo de 2010 Curso de programación en Java
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
31 mayo de 2010 Curso de programación en Java
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
32 mayo de 2010 Curso de programación en Java
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
33 mayo de 2010 Curso de programación en Java
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
34 mayo de 2010 Curso de programación en Java
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
35 mayo de 2010 Curso de programación en Java
Colecciones (Biblioteca)
36 mayo de 2010 Curso de programación en Java
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
37 mayo de 2010 Curso de programación en Java
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
38 mayo de 2010 Curso de programación en Java
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
39 mayo de 2010 Curso de programación en Java
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
40 mayo de 2010 Curso de programación en Java
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(); }
41 mayo de 2010 Curso de programación en Java
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();
42 mayo de 2010 Curso de programación en Java
Collections (IV) Interfaces
• Transformaciones a arrays para antiguas APIs Object[] a = c.toArray(); // c collection of Strings
String[] a = c.toArray(new String[0]);
43 mayo de 2010 Curso de programación en Java
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),…
44 mayo de 2010 Curso de programación en Java
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!!
45 mayo de 2010 Curso de programación en Java
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
46 mayo de 2010 Curso de programación en Java
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); }
47 mayo de 2010 Curso de programación en Java
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); }
48 mayo de 2010 Curso de programación en Java
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
49 mayo de 2010 Curso de programación en Java
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
}
50 mayo de 2010 Curso de programación en Java
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>>();
51 mayo de 2010 Curso de programación en Java
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(); }
52 mayo de 2010 Curso de programación en Java
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());
53 mayo de 2010 Curso de programación en Java
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
54 mayo de 2010 Curso de programación en Java
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();
}
55 mayo de 2010 Curso de programación en Java
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
56 mayo de 2010 Curso de programación en Java
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();
}
57 mayo de 2010 Curso de programación en Java
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)
58 mayo de 2010 Curso de programación en Java
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)
59 mayo de 2010 Curso de programación en Java
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.
60 mayo de 2010 Curso de programación en Java
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.
61 mayo de 2010 Curso de programación en Java
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.
62 mayo de 2010 Curso de programación en Java
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
63 mayo de 2010 Curso de programación en Java
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
64 mayo de 2010 Curso de programación en Java
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
65 mayo de 2010 Curso de programación en Java
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.
66 mayo de 2010 Curso de programación en Java
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
67 mayo de 2010 Curso de programación en Java
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.
68 mayo de 2010 Curso de programación en Java
Concurrencia (Threads)
69 mayo de 2010 Curso de programación en Java
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
70 mayo de 2010 Curso de programación en Java
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
71 mayo de 2010 Curso de programación en Java
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
72 mayo de 2010 Curso de programación en Java
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
73 mayo de 2010 Curso de programación en Java
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
74 mayo de 2010 Curso de programación en Java
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
75 mayo de 2010 Curso de programación en Java
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
76 mayo de 2010 Curso de programación en Java
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
77 mayo de 2010 Curso de programación en Java
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
78 mayo de 2010 Curso de programación en Java
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
79 mayo de 2010 Curso de programación en Java
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
80 mayo de 2010 Curso de programación en Java
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
top related