S6-Contenedores

1. Programación
Orientada a Objetos
Tema: 3 Contenedores
Docente: Mg. Luis Fernando Aguas B

2. Las convicciones tienen el poder de crear y el poder
de destruir

3. Objetivo
1. Adquirir los conceptos
básicos relacionados con
la POO
2. Reconocer las
características de la POO
● 3.2 Contenedores Especiales
Contenido

4. Objetivos de Desarrollo Sostenible

5. 3.2 Contenedores Especiales

6. Paquetes
 Clases de java se pueden agrupar en paquetes.
 Nombres de paquetes separados por . Como
 java.io.* // clases de E/S y archivos
 java.util.* // contenedores, date/time,
 java.lang.* //clases básicas de java, importadas
automáticamente
• Math, Integer, Double, System, Thread, String, etc
 javax.swing.* // clases soporte gráfico
 java.net.* // clases soporte comm en red, sockets, URLs
 Para garantizar nombres de paquetes únicos Sun recomienda dar
nombres en sentido inverso a dominios en urls
 Los archivos de paquetes creados deben seguir jerarquía de
directorios dados en secuencia dada en nombre paquete
 cl.udec.inf.sc.pedro : Clases definidas en pedro debe estar en
directorio cl/udec/inf/sc/pedro

7. Importando paquetes
 Para importar paquetes de clases ya definidos usar import
 Ejemplos
 import java.util.* // incluye un conjunto de contenedores
definidos en java como ArrayLists, Vectors, HashMaps,
Lists, etc
 import java.io.* // incluye clases de clases para
entrada/salida
 import java.lang.* // import no necesario
 Si nombre de clase en un paquete es igual a otra en otro
paquete y ambos son importados, de debe usar el nombre
de paquete con clase. Ejemplo
 java.util.Date y java.sql.Date

8. Creando paquetes
 Para poner una clase en un paquete se agrega
la sentencia de package nombre paquete
package cl.udec.inf.pedro;
public class Cuenta{
…
}
 Cuando la sentencia package no se agrega la
clase pertenece al paquete por defecto

9. Implementaciones de Colecciones
en Java
 ArrayList implementa List (usando arreglos)
 LinkedList implementa List (usando listas
enlazadas)
 HashSet implementa Set (usando tablas hash)
 TreeSet implementa Set (usando árboles)
 HashMap implementa Map (usando tablas
hash)
 TreeMap implementa Map (usando árboles)

10. Arrays, ArrayLists, Vectors
 Arrays pueden contener datos primitivos u objetos mientras que ArrayLists
sólo objetos
 Arrays son de tamaño fijo, mientras que ArrayLists crecen dinámicamente
 ArrayLists en Java 6.0
• Como templates en C++
• Tipo de objeto especificado en momento de creación de ArrayList
• ArrayList<String> vec1 = new ArrayList<String>();
• ArrayList<String> vec2 = new ArrayList<String>(10);
• Algunos métodos comunes
• Add, remove, size, get, contains, indexOf, isEmpty, etc
 Ventaja de ArrayList
• No se necesita saber tamaño a priori
 Desventaja
• No se puede ocupar la notación [] para obtener elementos
 Vectors
 Similar a ArrayLists
• Métodos de acceso sincronizados, luego más lento
• Se puede usar notación [] directamente, además de una serie de otros métodos
 LinkedLists
 Lento acceso itemes individuales, rápido al agregar

11. Hebras y Sincronización
● Hebra
○ Una secuencia de sentencias de código
que puede estar en ejecución concurrente
con otras hebras
○ Para crear hebras en Java
■ Crear una clase que implementa la
■ Clase que implementa interface Runnable
● Class A implements Runnable
■ Clase derivada de clase Thread
● Class A extends Thread

12. Creando hebras
/** Opción 1 */
import java.lang.*;
public class A extends Thread
{
private: …
public A(){…}
public void run()
{
....
}
public static void main(String[] args){
A thread1 = new A();
thread1.start();
}
}
/** Opción 2 */
import java.lang.*;
public class B implements Runnable
{
private: …
public B(){…}
public void run()
{
....
}
public static void main(String[] args){
B b = new B();
Thread thread1 = new Thread(b);
thread1.start();
}
}

13. Otras operaciones sobre hebras
● join
○ Permite a una hebra esperar por la terminación de otra
● sleep
○ Una hebra puede dormir por un tiempo dado
■ Método estático

14. Manejando hebras en Java 6
● Soporte para aplicaciones concurrentes
○ Aplicación crea y maneja hebras
■ Mediante uso de clase Thread o interface Runnable
○ Pasar tareas concurrentes a clase Executor
■ API para crear y manejar hebras
■ Proporciona pool de hebras para aplicaciones de gran escala

15. Sincronización
 Sincronización
 Keyword synchronized para indicar, bloque o método sincronizado,
sólo una hebra puede ejecutarse dentro de bloque o método
sincronizado
 Paquete java.util.concurrent
 Operaciones atómicas: (concurrent.atomic)
• Acciones atómicas sobre variables volátiles
• Variable volatile utilizada para decir a compilador que variable puede
ser modificada por múltiples hebras y se necesita último valor
almacenado
 Estructuras de datos accesadas atomicamente
• Colas, listas, tablas hash, etc.
 Locks
• Hasta java 1.4 cada objeto tiene un lock asociado
• Desde java 1.5 construcciones de locks para locks, LectoresEscritores y
locks reentrantes
 Semáforos
• Desde java 1.5
• http://java.sun.com/javase/6/docs/api/
 Monitores
• Usar keyword synchronized para exclusión mutua en métodos
• Hasta java 1.4 sólo soportaba una variable de condición por objeto
• wait() y notifyAll() como acciones en variable de condición (En Java, única
por objeto)
• Monitor tipo Mesa luego, wait() debe ser encerrado en ciclo while()

16. Ejemplo Productor-Consumidor con
semáforos
import java.util.concurrent.Semaphore;
public class QueuePC {
private int size;
private Object[] queue;
private int inptr = 0;
private int outptr = 0;
private int count = 0;
private Semaphore vacios;
private Semaphore llenos;
private Semaphore mutex;
public QueuePC(Integer size) {
this.size = size.intValue();
queue = new Object[size];
vacios = new Semaphore(size, true);
llenos = new Semaphore(0, true);
mutex = new Semaphore(1, true);
}

17. Productor consumidor Semáforos
public void put(Object value) throws
InterruptedException {
vacios.acquireUninterruptibly();// WAIT()
mutex.acquireUninterruptibly();
queue[inptr] = value;
System.out.println("P : " + count);
inptr = (inptr + 1) % size;
count++;
mutex.release();// SIGNAL()
llenos.release();
}

18. Productor consumidor Semáforos
public Object get() throws InterruptedException {
Object value;
llenos.acquireUninterruptibly();
mutex.acquireUninterruptibly();
value = queue[outptr];
outptr = (outptr + 1) % size;
count--;
System.out.println("C : " + count);
mutex.release();
vacios.release();
return value;
}

19. Productor consumidor Semáforos
public class Producer extends Thread {
private QueuePC buf;
private int id;
private static int number=0;
public Producer(QueuePC buf, Integer id) {
this.buf = buf;
this.id = id.intValue();
this.setName(new String(id.toString()));
}
public void run() {
for (int i = 1; i <= 50; i++) {
try {
System.out.println("Produciendo item : " + i);
buf.put(new Integer(number++));
} catch (InterruptedException e) {
System.out.println("Error al producir : " +
e.getMessage());
}
}
}
}

20. Productor consumidor Semáforos
public class Consumer extends Thread {
private QueuePC buf;
private int id;
public Consumer(QueuePC buf, Integer id) {
this.buf = buf;
this.id = id.intValue();
this.setName(new String(id.toString()));
}
public void run() {
for (int i = 1; i <= 50; i++) {
try {
Object j = buf.get();
System.out.println("tConsumiendo : " +
j.toString());
} catch (InterruptedException e) {
System.out.println("Error al consumir : " +
e.getMessage());
}
}
}
}

21. Productor consumidor Semáforos
import java.util.*;
/** Clase que define test de prueba para Problema
ProductorConsumidor usando semaforos */
public class TestSemPC {
public static void main(String[] args){
QueuePC queue = new QueuePC(new Integer(1));
Producer prod1 = new Producer(queue, new Integer(1));
Consumer cons1 = new Consumer(queue, new Integer(1));
Producer prod2 = new Producer(queue, new Integer(2));
Consumer cons2 = new Consumer(queue, new Integer(2));
Producer prod3 = new Producer(queue, new Integer(3));
prod1.start();
prod2.start();
prod3.start();
cons1.start();
cons2.start();
}
}

22. Gracias
Responsabilidad con pensamiento positivo