Revista java world cap 8,9,10

2Java World – Capítulo 7
h
t
t
p
:
/
/
g
u
s
t
a
v
o
a
l
b
e
r
o
l
a
.
b
l
o
g
s
p
o
t
.
c
o
m
Capítulo 8 – Clases internas
Una clase interna básicamente es lo que el nombre indica, una clase que se encuentra dentro de otra clase. Existen diferentes tipos
de ellas, y las maneras de instanciar las mismas también es diferente, de manera que las veremos una a una.
Durante el capítulo veremos 4 conceptos:
 Clases internas
o Clases internas normales
o Clases internas de método
o Clases internas anónimas
 Clases estáticas anidadas
Algunas reglas sobre las clases internas:
 Tienen acceso a todos los atributos y métodos de su clase contenedora, por más que los mismos sean private.
 Debe de existir una instancia de la clase contenedora para poder crear una instancia de la clase interna, sin excepción.
 Las clases internas siempre mantienen una referencia a la clase contenedora.
 Al igual que las clases normales, no es posible definirlas como abstract y final.
Clase interna normal
Primer punto a tener en cuenta, es que este código al precompilarlo genera dos clases:
 Externa.class
 Externa$Interna.class
Instanciación
Desde dentro de la clase externa, la clase interna es visible, de manera que lo siguiente es válido:
A su vez, la clase interna tiene conocimiento de la clase externa, pudiendo acceder a sus métodos y atributos como propios.
class Externa {
class Interna {
}
}
class Externa {
public void hazAlgo() {
Interna i = new Interna();
}
class Interna {
}
}
Una clase interna no puede tener métodos estáticos.

3 Java World – Capítulo 7
h
t
t
p
:
/
/
v
a
l
o
r
c
r
e
a
t
i
v
o
.
b
l
o
g
s
p
o
t
.
c
o
m
Instanciación fuera de la clase
Dado que una clase interna puede acceder a los atribútos y métodos de la clase externa, esto nos dice una cosa: “tiene que haber
primero una instancia de la clase externa para que pueda existir una instancia de la clase interna”.
Bien, según el código anterior, la instanciación de ambas clases desde fuera de la clase sería:
Referenciando a la clase externa desde la interna
Dado que el modificador this se encuentra reservado para el objeto que llamó el método actual en ejecución, no nos sirve para
invocar otra instancia. Para poder referenciar a instancia de la clase externa dentro de la interna la sintaxis sería:
[NombreClaseExterna].this
Modificadores aplicables
Los modificadores de acceso que se pueden aplicar a la clase interna normal son:
 final
 abstract
 public
 private
 protected
 static (transforma la clase en una clase común. Lo veremos más adelante)
 strictfp
Clase interna de método local
Es posible declarar una clase interna dentro de un método.
De manera que si quisieramos crear una instancia de Interna, esto solo podría realizarse dentro del método hazAlgo().
Externa externa = new Externa();
Externa.Interna interna = externa.new Interna();
class Externa {
class Interna {
public void hazOtraCosa() {}
}
}
}
El que hayas declarado una clase de método local no significa que hayas creado una instancia de esta clase.
class Externa {
class Interna {
Externa externa = Externa.this; //Referencia de la clase contenedora
Interna interna = this; //Referencia de la propia clase interna
}
}
}

h
t
t
p
:
/
/
g
u
s
t
a
v
o
a
l
b
e
r
o
l
a
.
b
l
o
g
s
p
o
t
.
c
o
m
Cosas que se pueden y no hacer dentro de una clase interna de método
 No se puede acceder a las variables definidas dentro del método, salvo que estas se definan como final.
 Puede acceder a los atributos de la clase externa.
o Solo podrá acceder a atributos estáticos, si es que fue declarada como static (no existe el this).
 La clase puede declararse dentro del método, pero la referencia puede almacenarse en otra referencia, de manrea que
finalizado el método el objeto siga existiendo.
Modificadores aplicables
Los modificadores de acceso que se pueden aplicar a una clase interna de método local son:
 abstract
 final
Clases internas anónimas
Estas conforman las porciones de código más extrañas que podamos encontrar en Java. Veamos un ejemplo primero:
El concepto de anónima viene porque se está sobreescribiendo una clase (o interfaz), pero no se está definiendo un nuevo tipo.
Conceptos a tener en cuenta de la clase anónima:
 La clase anónima puede extender de una clase normal, abstract o implementar una interface, pero solo puede
extender/implementar de una de las anteriores mencionadas (no puede extender de a e implementar la interfaz b).
 Desde fuera de la clase anónima solo se pueden invocar los métodos definidos en la super clase o interfaz.
 Se pueden crear nuevos métodos, pero estos solo pueden ser invocados desde otro método de la clase anónima.
 También es posible crear una clase anónima como parámetro de una función.
class ClaseDos {
public void hazAlgo() {}
}
class Original {
ClaseDos c = new ClaseDos() {
System.out.println("Método pop sobrescrito");
}
};
}
La declaración de una clase anónima debe cerrar la última llave con un ; (punto y coma), salvo que se este
definiendo como parámetro de un método.

h
t
t
p
:
/
/
v
a
l
o
r
c
r
e
a
t
i
v
o
.
b
l
o
g
s
p
o
t
.
c
o
m
Veamos un ejemplo de una clase anónima declarada como parámetro de un método, que a su vez extiende de una clase abstract.
Crear una clase anónima a partir de una interfaz
Una clase anónima puede implementar una interfaz, pero la declaración de la misma no es como se hace normalmente. Veamos un
ejemplo:
Como podemos apreciar, se utiliza tanto clases como interfaces de la misma manera en cuanto a clases anónimas se refiere.
new [Class o Interface]() {}
class Perro {
public void perseguir(Gato g) {
System.out.println("El perro comienza a perseguir al gato");
g.huir();
}
}
abstract class Gato {
abstract public void huir();
}
class Duenio {
Perro p = new Perro();
p.persegir(new Gato() {
public void huir() {
System.out.println("El gato logró huir exitosamente");
}
});
}
}
El perro comienza a perseguir al gato
El gato logró huir exitosamente
interface Animal {
public void emitirSonido();
}
class Familia {
Animal mascota = new Animal() {
public void emitirSonido() {
System.out.println("wof wof!");
}
};
mascota.emitirSonido();
}
wof wof!

h
t
t
p
:
/
/
g
u
s
t
a
v
o
a
l
b
e
r
o
l
a
.
b
l
o
g
s
p
o
t
.
c
o
m
Clases estáticas anidadas
Una clase estática anidada es simplemente una clase definida como un atributo estático de la clase padre.
Conceptos que cambian con respecto a las clases internas:
 No requieren de una clase externa para poder crear una instancia de la interna.
 No pueden acceder a atributos y métodos de la clase externa que no estén definidos como static.
 Se comporta como una clase normal, solo que la ruta de acceso es a través de ClaseExterna.ClaseInterna.
o Salvo en el caso que estemos en un método de la clase externa, en el cual la clase interna puede ser accedida
directamente como ClaseInterna.
Capítulo 9 – Hilos de ejecución (Threads)
Un hilo de ejecución es un proceso liviano desencadenado por otro proceso, y dependiente de este último. El nuevo hilo tendrá un
stack aparte.
En palabras más simples, un hilo de ejecución es un proceso paralelo con respecto al proceso principal, lo que lleva a cabo que en
computadoras con más de un nucleo (o emulados), haya varios procesos ejecutando nuestro código al mismo tiempo.
Que representa para Java un Thread?
 Una clase java.lang.Thread
 Un hilo de ejecución
Para el examen es necesario conocer cuando una sintaxis está creando código multithread seguro y cuando no.
class Persona {
static class Personita {
System.out.println("Personita hace algo");
}
}
}
public class General {
static class Cabo {
System.out.println("Cabo hace algo");
}
}
// Tener en cuenta que el método main está definido dentro de General
static public void main(String[] args) {
Persona.Personita p = new Persona.Personita();
Cabo c = new Cabo();
p.hazAlgo(); // Personita hace algo
c.hazAlgo(); // Cabo hace algo
}
}

h
t
t
p
:
/
/
v
a
l
o
r
c
r
e
a
t
i
v
o
.
b
l
o
g
s
p
o
t
.
c
o
m
Creando un thread
Dentro de la clase java.lang.Thread se encuentran una serie de métodos. Dentro de estos deberás de conocer los siguientes:
 start()
 yield()
 sleep()
 run()
Para poder crear un nuevo Thread debes de cumplir el contrato de la interfaz java.lang.Runnable, el cual tiene un solo método:
public void run();
Para ello, la clase que utilicemos tiene que implementar dicha interfaz, o extender la clase java.lang.Thread.
Definiendo un Thread extendiendo Thread
Definiendo un Thread implementando Runnable
Instanciando un Thread
Si o si es necesaria una instancia de Thread para poder correr un hilo de ejecución.
Para eso tenemos dos posibilidades, dependiendo de si extendimos de Thread, o implementamos Runnable.
Instanciando un Thread que extiende de Thread
Creamos un objeto MiClaseConThread y lo asignamos a una referencia de tipo Thread, dado que extiende de Thread, la relación Is-A
Thread es legal.
Instanciando un Thread que implementa Runnable
En este caso, lo que hacemos es primero crear una instancia de nuestra clase y almacenarla en una referencia de tipo Runnable.
Luego, utilizamos uno de los constructores sobrecargados de Thread, el cual recibe un objeto de tipo Runnable.
class MiClaseThread extends Thread {
public void run() {
System.out.println("Oh, JavaWorld esta en un Thread!");
}
}
class MiClaseRunnable implements Runnable {
public void run() {
System.out.println("Oh, JavaWorld esta en un Thread!");
}
}
Thread hilo = new miClaseConThread();
Runnable hiloRunnable = new miClaseConThread();
Thread hilo = new Thread(hiloRunnable);
// O la versión abreviada
Thread hilo = new Thread(new miClaseConThread());

h
t
t
p
:
/
/
g
u
s
t
a
v
o
a
l
b
e
r
o
l
a
.
b
l
o
g
s
p
o
t
.
c
o
m
La clase Thread
Como mencionamos anteriormente, Thread tiene una serie de constructores sobrecargados:
 Thread()
 Thread(Runnable objetivo)
 Thread(Runnable objetivo, String nombre)
 Thread(String nombre)
Si probamos los códigos anteriores en una aplicación en Java, notaríamos que no pasa nada. La cuestión es que el instanciar un
Thread no hace que se lance el hilo de ejecución del mismo, de manera que no se ejecuta. Para poder determinar en que
condiciones de ejecución se encuentra el Thread lo podemos clasificar en tres estados:
Estado Descripción
new
(nuevo)
Cuando un Thread ha sido instanciado (invocación del new) se encuentra en estado nuevo.
alive
(vivo)
Cuando el hilo de ejecución es lanzado (se crea un nuevo stack para el hilo y se ejecuta el contenido de run() ), se dice
que el Thread está vivo.
dead
(muerto)
Cuando el hilo de ejecución completa el método run, se dice que el Thread está muerto.
Iniciando la ejecución de un Thread
Simplemente, para iniciar la ejecución de un nuevo Thread, se utiliza el método start().
Tambien hay que tener mucho cuidado con la llamada a run(). Cuando invocamos el método start(), este primero crea un nuevo
stack, y luego lanza el método run() como miembro inicial de dicho stack en un hilo de ejecución aparte.
Runnable hiloRunnable = new miClaseConThread();
Thread hilo = new Thread(hiloRunnable);
hilo.start();
Si se invoca directamente el método run() no generará un error, pero el mismo no se ejecutará en un nuevo
thread, sino que sería como llamar a un método normal.

h
t
t
p
:
/
/
v
a
l
o
r
c
r
e
a
t
i
v
o
.
b
l
o
g
s
p
o
t
.
c
o
m
Ejecutando Threads
Vamos a lo que nos concierne, corramos algunos hilos:
Por más que conozcamos el orden en que son inicializados, ni siquiera esto nos asegura de que el orden de ejecución de los mismos
sea ese.
El sistema de hilos y tareas es manejado por el Sistema Operativo en conjunto con la JVM, son ellos quienes asignarán el proceso y
otorgaran los tiempos que el mismo se encuentra en ejecución.
Otra cuestión a tener en cuenta es que un Thread solo puede ser llamado una única vez en toda su existencia.
class PruebasRunnable implements Runnable {
private int iteraciones = 4;
public void run() {
for (int x = 0 ; x < iteraciones; x++ ) {
System.out.println("Ejecutando [" + Thread.currentThread().getName() + "] [" + x
+ "]");
}
}
Runnable hilo = new PruebasRunnable();
Thread hilo1 = new Thread(hilo, "Hilo 1");
hilo1.start();
hilo2.start();
hilo3.start();
}
}
Ejecutando [Hilo 1] [0]
El orden de ejecución de los hilos no puede ser jamás predecido.
El llamar al método start() más de una vez desde el mismo Thread generará el lanzamiento de una
excepción IllegalThreadStateException.

h
t
t
p
:
/
/
g
u
s
t
a
v
o
a
l
b
e
r
o
l
a
.
b
l
o
g
s
p
o
t
.
c
o
m
Estados y transiciones de los threads
En total podemos contar 5 estados en los cuales puede estar un thread. Veamos un gráfico de esto para entender un poco mejor:
Tabla de estados
Estado Descripción
New
(nuevo)
Este estado se da cuando se ha invocado al new del Thread, pero aun no se ha llamado al método
start().
Runnable
(esperando ejecución)
Este estado se da cuando el thread se encuentra listo para ser ejecutado, y está esperando que el
gestionador de eventos de la JVM lo seleccione para comenzar la ejecución.
Running
(en ejecución)
Este estado se da cuando el thread fue seleccionado por el gestionador de eventos y se encuentra
actualmente en ejecución.
Waiting/Block
(esperando/bloqueado)
Este estado se da cuando el thread requiere algún recurso (I/O por ejemplo), de manera que para
no consumir recursos de CPU queda esperando. También puede pasar que se le haya ordenado que
se durmiera, de manera que despertará cuando acabe el tiempo (si se especificó), o que otro thread
le envíe una señal para despertarlo.
Dead
(muerto)
Este estado se da cuando el thread completó la ejecución del método run. Aun sigue siendo un
objeto, el cual solicito que se liberarn sus recursos.
Durmiendo (Sleep)
Sleep es un método estático de la clase Thread. Este solo puede afectar al Thread que actualmente se está ejecutando, de manera
que un Thread no puede dormir a otro.
Cuando un Thread es enviado a dormir pasa al estado de “Esperando/Bloqueado”.
Los métodos sleep son:
 sleep()
 sleep(long milisegundos)
El primero envía el thread a “Esperando” hasta que otro thread lo despierte mediante “nofity/notifyAll”.
El segundo lo duerme por un tiempo determinado.
New
(nuevo)
Runnable
(esperando
ejecución)
Running
(en
ejecución)
Waiting
/Blocking
(esperando
/bloqueado)
Dead
(muerto)
Alive (vivo)
Cuando se especifica un tiempo de sleep, este representa el tiempo mínimo que el thread permanecerá
dormido, pero no es el tiempo exacto.

h
t
t
p
:
/
/
v
a
l
o
r
c
r
e
a
t
i
v
o
.
b
l
o
g
s
p
o
t
.
c
o
m
Además, este método puede generar una excepción InterruptedException, por lo que hay que llamarlo dentro de un Try-Catch.
Hagamos un ejemplo simple:
Yield() y threads con prioridades
Los threads siempre se ejecutan con una prioridad, generalmente, esta se representa con un número del 1 al 10.
Algunas JVM´s utilizan una lógica de “tiempo cíclico”, la cual asigna un tiempo determinado a un thread para que se ejecute. Si el
thread excede el tiempo, se pausa su ejecución, y se devuelve a la lista de “esperando ejecución”, dando la oportunidad a otro
thread para que se ejecute. Otras utilizan una lógica que permiten a un thread ejecutarse hasta la finalización del método run.
Las prioridades funcionan de manera que se ordena la lista de “esperando ejecución” de menor a mayor por prioridad, siempre
pasando a “en ejecución” a los threads de mayor prioridad.
Esto nos deja con dos posibles comportamientos:
 Se obtiene un thread de la lista de “esperando ejecución” y se lo ejecuta hasta que se complete o se bloque.
 Se utilizan tiempos máximos de ejecución, de manera que todos los threads (o la gran mayoría), tengan una oportunidad de
ejecutarse.
Estableciendo la prioridad de los threads
El thread recibe una prioridad por defecto, la cual corresponde a la prioridad del thread con que fue creado. Esta comprende un
rango que va generalmente del 1 al 10, pero no todas las JVM´s contienen este rango.
Por defecto, los threads main son creados con prioridad 5.
Existen también algunos identificadores en la clase Thread para indicar las prioridades:
 Thread.MIN_PRIORITY 1
 Thread.NORM_PRIORITY 5
 Thread.MAX_PRIORITY 10
La prioridad se establece mediante el método setPriority(int prioridad). Este es un método de instancia perteneciente a la clase
Thread.
import java.lang.InterruptedException;
public class PruebasRunnable01 implements Runnable {
(new Thread(new PruebasRunnable01())).start();
}
public void run() {
for (int x = 1 ; x <= 101 ; x ++) {
if (x%10 == 0) {
System.out.println("Running " + x);
}
try {
Thread.sleep(500); // 1 milisegundo * 500 = 1/2 segundo
} catch(InterruptedException ex) {}
}
}
}
La JVM no especifica que las prioridades se sigan al pie de la letra, de manera que solo utilizamos estas para
optimizar el código, pero no dependan de ellas para determinar la lógica del programa.

h
t
t
p
:
/
/
g
u
s
t
a
v
o
a
l
b
e
r
o
l
a
.
b
l
o
g
s
p
o
t
.
c
o
m
Ejemplo:
La JVM nunca cambiará la prioridad de un thread.
El método yield()
Este método lo que hace es enviar una sugerencia a la JVM para que el thread actual pase a la lista de “esperando ejecución”. Pero
hay que tener en cuenta que esto es una sugerencia, y puede que nunca se cumpla. También puede que se cumpla, pero al enviar el
thread a la lista de “esperando ejecución”, vuelva a ser elegido el mismo y pase a la lista de “en ejecución”.
Mediante el método yield(), el thread nunca pasará al estado de “Esperando”. Este es un método de clase perteneciente a la clase
Thread.
El método join()
Este método permite unir la ejecución de un thread al final de la otra. Supongamos que tenemos dos threads A y B. A requiere que B
se ejecute para poder continuar, de manera que A realiza un join contra B. Cuando B termine su ejecución, recién en ese momento A
será candidato a ser elegido de la lista de “esperando ejecución”, pero no antes.
Este es un método de instancia perteneciente a la clase Thread.
Sincronización de código
La sincronización es el termino utilizado para que varios elementos que utilizan un recurso compartido no generen inconsistencia de
datos.
En el siguiente ejemplo de código pueden ver un caso en particular con una cuenta bancaria. Ejecutenlo varias veces y verán como a
veces el saldo queda en negativo y otras no.
Para ver el ejemplo, dirígete al enlace y compila el código.
Lo que debemos hacer en orden de preservar la integridad de la cuenta es que el método “efectuarRetiro” se realice de manera
atómica (en realidad el término no es del todo correcto, dado que una operación atómica es aquella que solo contiene una
instrucción. En este caso, se utiliza para identificar un conjunto de instrucciones que deben de procesarse como una sola).
Para ello podemos utilizar el modificador synchronized. Este lo que hace es asegurarse de que solo un objeto por vez pueda
acceder al recurso (en este caso el método), pero no asegura que el objeto ejecute en una pasada todo el código.
Si un objeto ejecuta el código y se interrumpe dentro del mismo, se mantiene una llave, de manera que otro objeto no pueda
acceder hasta que el que estaba bloqueado, vuelva y termine con la ejecución.
Veamos el mismo ejemplo pero ahora sincronizado. Ejecutenlo las veces que quieran. Verán que el saldo de la cuenta jamás será
negativo.
Para ver el ejemplo, dirígete al enlace y compila el código.
Thread t = new MiThread();
t.setPriority(Thread.MAX_PRIORITY);
t.start();

h
t
t
p
:
/
/
v
a
l
o
r
c
r
e
a
t
i
v
o
.
b
l
o
g
s
p
o
t
.
c
o
m
Sincronización y bloqueos
La sincronización funciona mediante bloqueos. Denominamos bloqueo al método que implementa synchronized, y monitor al
objeto que accede al bloqueo.
Puntos clave sobre synchronized:
 Solo se pueden sincronizar métodos o bloques de código.
 Cada objeto solo tiene un bloqueo.
 No es necesario sincronizar todos los métodos de una clase.
 Solo puede acceder un monitor al bloqueo por vez.
 Si se utiliza la sincronización en forma incorrecta, se pueden llegar a generar deadlocks (bloqueos de la muerte). Esto
sucede cuando dos objetos, contienen un bloqueo, y ambos requieren acceder al bloqueo del contrario.
 Si un thread pasa a “esperando/bloqueado”, este mantiene todos los bloqueos que tiene (continua siendo monitor).
 Un thread puede adquirir más de un bloqueo.
 Es posible sincronizar un bloque de código en vez de un método completo.
//Método de instancia sincronizado
public synchronized hazAlgo() {
System.out.println("Codigo sincronizado");
}
//Bloque de código de instancia sincronizado
synchronized(this) {
System.out.println("Codigo sincronizado");
}
}
//Método de clase sincronizado
static public synchronized hazAlgo() {
System.out.println("Static - Codigo sincronizado");
}
//Bloque de código de clase sincronizado
static public hazAlgo() {
synchronized(MyClase.class) {
System.out.println("Static - Codigo sincronizado");
}
}

h
t
t
p
:
/
/
g
u
s
t
a
v
o
a
l
b
e
r
o
l
a
.
b
l
o
g
s
p
o
t
.
c
o
m
Que pasa si un thread no obtiene el bloqueo?
Si un objeto intenta acceder a por ejemplo un método sincronizado, y este ya está bloqueado, el objeto en cuestión queda en una
lista de espera especial para cuando el bloqueo sea liberado.
No hay una lógica que indique en que orden se obtiene el próximo objeto que se encuentra en la lista esperando el bloqueo.
Cuadro de cómo afectan los métodos de threads a los bloqueos
Libera el bloqueo Mantiene el bloqueo Clase que contiene el método
wait() notify() java.lang.Object
join() java.lang.Thread
sleep() java.lang.Thread
yield() java.lang.Thread
Cuando es necesario sincronizar?
Generalmente, siempre que utilicemos threads será necesario que hagamos uso de la sincronización, siempre que tanto en métodos
estáticos como no estáticos, haya datos que puedan sufrir modificaciones y que no sean de tipo local, se deberán de marcar como
synchronized.
Hay un pequeño tema, dijimos que cada clase tiene un bloqueo disponible, pero es uno para la clase y uno para la instancia (static
y no static). El problema es que si un método de clase llama a un atributo estático, y el primero está sincronizado, solo se toma un
bloqueo, el de la clase. Y si otro objeto llama al método estático, y este llama al atributo de clase, solo se toma el bloqueo estático. Y
con esto ambos objetos pudieron saltear los bloqueos del otro.
De más está decir que esta situación debes evitarla siempre que sea posible de manera que:
 Los atributos estáticos solo se deben invocar desde métodos estáticos sincronizados.
 Los atributos de clase solo se deben invocar desde métodos de clase sincronizados.
Clases multi-hilo seguro
Cuando una clase contiene métodos synchronized cuidadosamente colocados, se denomina que la clase es multi-hilo seguro
(Thread-Safe). Pero hay un problema, que la clase sea thead-safe no quita que podamos implementarla de manera incorrecta,
produciendo posibles corrupciones de datos.
De manera que cuando utilicemos threads, debemos depender de la clase que llevaría a cabo la operación atómica.
Bloqueos de la muerte
Esto se produce cuando dos bloqueos esperan que se libere el bloqueo del contrario para poder continuar. Esto generalmente es un
error muy difícil de detectar, además de que cuando trabajamos con threads, el reproducir el error es aun más complicado.
Interacción entre threads
Para comunicarse entre si, se utilizan los método: wait(), notify() y notifyAll().
Los métodos wait() y notify() pertenecen a la clase Object.
Un objeto puede tener una lista con 0 .. * (0 a muchos) objetos esperando que se les notifique cuando la ejecución de este haya
terminado, o el bloqueo se haya liberado. Veamos un ejemplo:
wait(), notify(), notifyAll() solo pueden ser invocados desde un contexto sincronizado. Un objeto no puede
ionvocar dichos métodos a menos que posea el bloqueo.

h
t
t
p
:
/
/
v
a
l
o
r
c
r
e
a
t
i
v
o
.
b
l
o
g
s
p
o
t
.
c
o
m
En el código anterior, no se ejecuta la sentencia que muestra el total hasta que Incrementador no emite el notify indicando que
puede continuar.
La importancia del código anterior radica en que para poder llamar al método wait del objeto bloqueador, se debe de poseer el
bloqueo del mismo.
//Compilación: javac -g PruebasRunnable04.java
//Ejecución: java PruebasRunnable04
public class PruebasRunnable04 {
(new PruebasRunnable04(new Object())).pruebaWait();
}
private Object bloqueador;
public PruebasRunnable04(Object bloqueador) {
this.bloqueador = bloqueador;
}
public void pruebaWait() {
Incrementador incrementador = new Incrementador(bloqueador);
(new Thread(incrementador)).start();
synchronized(bloqueador) {
try {
System.out.println("Esperando a que se complete el incrementador...");
bloqueador.wait();
} catch(InterruptedException ex) {}
System.out.println("El total es: " + incrementador.getTotal());
}
}
}
class Incrementador implements Runnable {
private int contador = 0;
private Object bloqueador;
public Incrementador(Object bloqueador) {
this.bloqueador = bloqueador;
}
public int getTotal() {
return contador;
}
public void run() {
synchronized(bloqueador) {
for(int x = 0 ; x < 100 ; x++) {
contador++;
System.out.print(".");
try {
Thread.sleep(100);
} catch(InterruptedException ex){}
}
System.out.println();
bloqueador.notify();
}
}
}

h
t
t
p
:
/
/
g
u
s
t
a
v
o
a
l
b
e
r
o
l
a
.
b
l
o
g
s
p
o
t
.
c
o
m
Al igual que sleep(), wait() contiene una sobrecarga: wait(long milisegundos). Esto tiene como propósito poner un límite de tiempo
en la espera, ejecutando lo que ocurra primero (ya sea notify() o el tiempo ha transcurrido).
Utilizando notifyAll() cuando varios threads puedan estar esperando
Si más de un thread se encontraba esperando que se le notifique, al ejecutar notifyAll() todos aquellos que se encuentren en dichas
condiciones competirán por parar al estado “en ejecución”.
Utilizando wait() en un bucle
Uno de los casos que podemos encontrar y que no hemos planteado aun es el hecho de que el notify() se ejecute antes que el wait().
¿Qué pasaría en esta situación?...
Simple, si un objeto estuviera esperando un notify() que no volverá a ejecutarse (esto es así por nuestra lógica del programa), el
thread estará esperando eternamente, o hasta que se genere una interrupción (InterruptedException).
Capítulo 10 - Deployment
Todo desarrollo en Java requiere que los archivos sean pre-compilados a bytecodes, los cuales son almacenados en archivos .class, o
porque no comprimir todos tus .class en un paquete .jar.
Un recordatorio que mencionamos en el primer capítulo. Para poder compilar los archivos .java debes tener instalada alguna
versión de la JDK (Java Development Kit), no basta con tener la JRE (Java Runtime Environment) instalada.
Compilando con con javac
Javac es el comando utilizado para poder transformar nuestros .java a .class (bytecodes). La sintaxis de este es:
javac [opciones] [archivos de código fuente]
Los elementos entre [] significan opcional.
Múltiples opciones y/o archivos de código fuente deben separarse con caracteres de espacio.
Opcion –d
Por defecto, cuando compilemos nuestros archivos en Java, el directorio destino por defecto será exactamente el mismo que el de
los códigos fuente. Para poder modificar esto existe el comando –d.
Cuando se ejecuta un notify() no quiere decir que se libere el bloqueo. Esto se realizará una vez que se salga
del código sincronizado.
El directorio que especifiques mediante –d debe existir, de lo contrario generarás un error de compilación.

h
t
t
p
:
/
/
v
a
l
o
r
c
r
e
a
t
i
v
o
.
b
l
o
g
s
p
o
t
.
c
o
m
Supongamos la siguiente estructura.
Dentro de source van nuestro .java y dentro de classes nuestros .class.
Si quisiéramos compilar el código anterior (tengan en cuenta que según la estructura anterior, PruebaJavaWorld.java esta dentro de
los package com, blogspot y gustavoalberola) deberíamos utilizar la sintaxis:
Parados sobre el directorio “source”
javac –d ../classes com/blogspot/gustavoalberola/PruebaJavaWorld.java
Esto lo que hará es crear dentro de classes la misma jerarquía de directorios, con el .class compilado a bytecode.
Ejecutando aplicaciones con java
Una vez que tenemos nuestros .class lo que necsitamos es ejecutar el programa, para ello utilizamos el comando java. Su sintaxis es:
java [opciones] clase [argumentos]
Por defecto, el comando java interpreta que lo que quieres ejecutar es un .class, de manera que no es necesario especificar la
extensión (es más, si la especificas, no podrás ejecutar tu programa).
Utilizandos las propiedades de sistema
Dentro de java tenemos una clase denominada java.util.Properties. Esta es utilizada para obtener las propiedades por defecto del
sistema operativo, el compilador de java, la jvm, y también para guardar nuestras propias propiedades.
Veamos un ejemplo simple:
Directorio Raiz
source
classes
com
gustavoalberola
blogspot
PruebaJavaWorld.java
import java.util.Properties;
public class Pruebas_01 {
Properties propiedades = System.getProperties();
propiedades.setProperty("MiPropiedad", "MiValor");
propiedades.list(System.out);
}
}

h
t
t
p
:
/
/
g
u
s
t
a
v
o
a
l
b
e
r
o
l
a
.
b
l
o
g
s
p
o
t
.
c
o
m
Ejecutando el programa con:
java -DMyOtraPripiedad="Aun no decido que valor poner" Pruebas_01
El resultado es algo asi:
Vemos como tanto la variable que declaramos en código, como aquella que introducimos mediante –D existen en el listado de
propiedades.
Manejando argumentos de la línea de comandos
Todos losargumentos que se escriban en el momento de ejecución entran en el array de Strings del método main, empezando por el
índice 0 para el primer argumento, y así sucesivamente.
Ejecutando el comando
java Pruebas_02 soy1 "Y yo que?" 1234568
java.runtime.name=Java(TM) SE Runtime Environment
sun.boot.library.path=C:Program FilesJavajre6bin
java.vm.version=14.3-b01
java.vm.vendor=Sun Microsystems Inc.
java.vendor.url=http://java.sun.com/
...
java.runtime.version=1.6.0_17-b04
...
java.specification.version=1.6
user.name=gustavo
java.class.path=.
MyOtraPripiedad=Aun no decido que valor poner
...
MiPropiedad=MiValor
public class Pruebas_02 {
int x = 0;
for(String s : args) {
System.out.println("Argumento [" + x++ + "] = " + s);
}
}
}
Argumento [0] = soy1
Argumento [1] = Y yo que?
Argumento [2] = 1234568

h
t
t
p
:
/
/
v
a
l
o
r
c
r
e
a
t
i
v
o
.
b
l
o
g
s
p
o
t
.
c
o
m
Buscando otras clases
Cuando compilamos o ejecutamos una aplicación, esta requiere de otras clases para funcionar. Supongamos que estamos en la
sección de I/O, y necesitamos la clase File, esta tendría que buscarse en java.io.File. Para ello, java realiza las siguientes acciones:
 Tanto java como javac buscan otras clases de la misma manera
 Se procede a buscar una a una las clases necesarias
o Se busca dentro de las clases que vienen estandar con J2SE
o Se busca dentro de los classpath declarados
 La búsqueda se detiene en la primer coincidencia.
 El classpath puede ser declarado de dos maneras:
o Como variable del sistema operativo
o Como argumento en la línea de comandos (si se especifica, sobrescribe al classpath de sistema, solo en dicha
invocación).
Declarando y utilizando classpaths
El classpath es una dirección a nivel de directorio en donde se buscaran las clases necesarias para compilar/ejecutar el programa.
El classpath a su vez puede estar conformado por varios classpath concatenados mediante un caracter parser que hace de
separador.
Hay que tener en cuenta que una estructura de directorio se especifica diferente según el S.O. que estemos utilizando:
 Unix: se utiliza como directorio el / y como separador el :
 Windows: se utiliza como directorio el y como separador el ;.
Un ejemplo de classpath válido para windows sería:
.classes;c:misProyectosclasses;c:;
Muchas veces cuando ejecutamos un programa podemos toparnos con una excepción ClassNotFoundException. Esto indica que
la JVM no pudo localizar alguna clase que nuestro programa requiere.
Los classpaths se recorren de izquierda a derecha.
Package y búsqueda
Existen dos maneras de referenciar clases desde nuestro código que se encuentran en otro package, mediante imports, o la
llamda con el nombre atómico de la clase (el package.classNombre).
Cuando se utiliza el comando java, este no busca en el directorio donde esta parado las clases, solo en el
directorio de la JRE. Para que haga lo primero, es necesario especificarlo mediante la opción –classpath o –
cp.
package com.blogspot.gustavoalberola;
public class JavaWorld {}

h
t
t
p
:
/
/
g
u
s
t
a
v
o
a
l
b
e
r
o
l
a
.
b
l
o
g
s
p
o
t
.
c
o
m
Dicha clase será almacenada en com/blogspot/gustavoalberola/JavaWorld.java.
Para referenciarlo desde otro package podemos utiliza cualquiera de las dos sentencias a continuación:
Modo de referencia atómico
Modo de referencia mediante imports
Paths relativos y absolutos
La diferencia entre un path relativo y absoluto es:
 El path relativo depende de donde se encuentra el directorio actual. Ejemplo: ../ vuelve un directorio hacia arriba.
 El path absoluto siempre referencia al mismo lugar sin importar donde se encuentre el directorio actual. Ejemplo:
c:Jre_6_0_17.
Archivos JAR
Teniendo nuestra aplicación terminada, es probable que quieras comenzar a distribuirla. Puedes tener todos los .class en sus
respectivos directorios y distribuirlos solo de esa manera, o puedes generar unn archivo jar que contenga todos los .class.
Algunas reglas con respecto a los .jar
 Automáticamente genera un directorio META-INF.
 Automáticamente genera un archivo MANIFEST.MF dentro del directorio anterior.
 Jamás introducirá ninguna de tus clases dentro del directorio META-INF.
 Se copia la estructura del directorio y subdirectorios tal cual estaba en el file system.
 Los comandos java y javac utilizan el .jar con una estructura de directorio normal.
//otro package
public class OtraClase {
com.blogspot.gustavoalberola.JavaWorld javaWorld;
javaWorld = new com.blogspot.gustavoalberola.JavaWorld();
}
}
//otro package
//Tambien podemos utilizar el * en vez de JavaWorld (importa todas las clases del
package)
import com.blogspot.gustavoalberola.JavaWorld;
public class OtraClase {
JavaWorld javaWorld;
javaWorld = new JavaWorld();
}
}
Cuando queremos compilar o ejecutar una clase que requiere de otra que se encuentra en un .jar, es
necesario especificar en el classpath el directorio junto con el nombre y extensión del .jar.
Ejemplo: java -cp=libs/JavaWorld.jar HolaJavaWorld

h
t
t
p
:
/
/
v
a
l
o
r
c
r
e
a
t
i
v
o
.
b
l
o
g
s
p
o
t
.
c
o
m
Utilizando …/jre/lib/ext
Cuando instanalamos la JRE, dentro de uno de sus directorios
encontramos jre/lib/ext. Dentro se encuentran todas las clases que java
utiliza. Si pusiéramos cualquiera de nuestras clases aquí dentro, no
necesitaríamos especificar un classpath para referenciarlas.
Esto es una práctica poco común, y solo se aconseja para casos personales,
pero no como método de distribución de un programa.
También es importante saber que es muy común encontrar variables
definidas para abreviar un directorio, como por ejemplo JAVA_HOME. Si
ves en el examen esto, interpretalo como el directorio de las librerías de
java.
Utilizando import estáticos
El import estático se utiliza para no tener que escribir el nombre completo
de la constante, método o atributo estático. Ejemplo:
Muchos aseguran que esto ahorra un par de tecleados a cambio de perder
en la redibilidad del código.
Fin del camino
Con esta última entrega concluimos la
saga de Java World SCJP. Ha sido un
camino largo y les agradecemos a todos
aquellos que nos estuvieron siguiendo
todo este tiempo, a aquellos que
realizaron comentarios y correcciones
sobre los capítulos previos, y a la
comunidad en general.
Nos quedan un par de cositas para subir
además de la compilación final de todos
los capítulos para que les sea más fácil
descargarlos.
Esperamos que el material les sea de
ayuda y cualquier duda o comentario
que tengan no duden en publicar sus
comentarios en el blog.
Gracias a todos!
import static System.out;
public class HolaMundo {
out.println("Hola mundo");
}
}
La llamada debe ser import static, y solo en
ese orden.

Revista java world cap 8,9,10

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (18)

Destaque

Destaque (20)

Semelhante a Revista java world cap 8,9,10

Semelhante a Revista java world cap 8,9,10 (20)

Mais de Hack '

Mais de Hack ' (20)

Revista java world cap 8,9,10