Chap 15bpin

Extending the Thread Class
Se puede crear un hilo escribiendo una
clase que extienda a la clase
java.lang.Thread y sobre escriba al
método run() en Thread.
La clase GuessANumber extiende a
Thread y escoge un número aleatoria
mente entre 1 y 100 hasta que adivine el
entero almacenado en el campo number.

public class GuessANumber extends Thread
{
private int number;
public GuessANumber(int number)
{
this.number = number;
}
public void run()
{
int counter = 0;
int guess = 0;
do
{
guess = (int) (Math.random() * 100 + 1);
System.out.println(this.getName() + " guesses " + guess);
counter++;
}while(guess != number);
System.out.println("** Correct! " + this.getName() + " in " + counter +
"guesses.**");
}
}

Cuando UD. extiende la clase Thread,
UD. se ahorra un paso cuando crea e
inicia un hilo por que un objeto Runnable
y un objeto Thread son objetos iguales.
( La clase Thread implementa la interface
Runnable, así cualquier clase hija de
Thread es también de tipo Runnable.)

El siguiente programa ThreadDemo
instancia dos objetos GuessANumber,
luego los inicia a ambos.
Cada hilo corre hasta que se adivine el
número 20, el cual toma un número
arbitrario de guesses.

public class ThreadDemo
{
public static void main(String [] args)
{
System.out.println("Pick a number between 1 and 100...");
GuessANumber player1 = new GuessANumber(20);
GuessANumber player2 = new GuessANumber(20);
player1.start();
player2.start();
}
}

Yielding Threads
Un hilo se mantiene invocando el método
yield() de la clase Thread , este se ve así:
public static void yield()
Este método causa que el hilo que corre
actualmente se detenga para que los
otros hilos tengan oportunidad de
ejecutarse.

Yielding Threads
La siguiente clase GuessANumber2
modifica a la clase GuessANumber al
agregar a yield() dentro del método run():

public class GuessANumber2 extends Thread{
private int number;
public GuessANumber2(int number){
this.number = number;
}
public void run(){
int counter = 0;
int guess = 0;
do{
Thread.yield();
guess = (int) (Math.random() * 100 + 1);
System.out.println(this.getName() + " guesses " + guess);
counter++;
}while(guess != number);
System.out.println("** Correct! " + this.getName() + " in " + counter +
" guesses.**");
}
}

Yielding Threads
Estudie el siguiente programa
YieldDemo y trate de determinar que
sucede cuando los tres hilos se inician.

public class YieldDemo
{
{
System.out.println("Pick a number between 1 and
100...");
Thread player1 = new GuessANumber2(85);
player3.setPriority(Thread.MAX_PRIORITY);
player1.start();
player2.start();
player3.start();
}
}

Yielding Threads
Note que en el programa YieldDemo el
player3 tiene la prioridad máxima de un
Thread, la cual es de 10. Después de
cada guess, cada hilo invoca al método
yield(). Sin embargo, el player3 tiene una
prioridad alta, este no se mantiene para
permitir que los hilos placer1 o player2
entren al CPU.

Yielding Threads
El hilo player3 atrapa el CPU hasta que
termina su ejecución. Cuando el hilo del
player3 termina, los hilos player1 y player2
cortésmente toman su turno para obtener
su guessing number cada uno llama al
método yield() después de cada guess.

Yielding Threads
Si UD. desea que el hilo del player3
tenga una prioridad más baja, para
utilizar el CPU, el player3 se puede poner
a dormir por poco tiempo.
Use el método sleep() de la clase Thread
para causar que el hilo que actualmente
esta corriendo duerma:
public static void sleep( int millisec )
throws InterruptedException

Yielding Threads
Veamos cual es el efecto que sleep()
tiene en la clase GuessANumber2, al
acambiar el llamado a Thread.yield() por
lo siguiente:
try
{
Thread.sleep(1);
}match(InterruptedException e) {}

Methods of the Thread Class
Veamos en detalles los métodos de la
clase Thread.
La clase Thread tiene muchos métodos
útiles para determinar y cambiar la
información acerca de un hilo, incluyendo:

public void start(). Inicia un hilo en un
sendero de ejecución, luego invoca al método
run() en este objeto Thread.
public void run(). Si este objeto Thread fue
instanciado usando un destino Runnable por
separado, el método run() es invocado en este
objeto Runnable. Si UD. Escribe una clase que
extiende a Thread, el método sobre escrito
run() en la clase hija es invocado.

public final void setName(String name).
Cambia el nombre del objeto Thread. También
existe el método getName() para obtener el
nombre.
public final void setDaemon( boolean on ).
Un parámetro true denota a este Thread como
un hilo demonio. Para el hilo que es un demonio,
este método debe ser invocado antes de que el
hilo inicie.

public final void setPriority ( int priority ).
Asigna la prioridad de este objeto Thread. Los
posibles valores están entre 1 y 10. Sin
embargo los desarrolladores se animan a usar
los siguientes tres valores:
Thread.NORM_PRIORITY,
Thread.MIN_PRIORITY y
Thread.MAX_PRIORITY ( cuyos valores son 5,
1 y 10 respectivamente).

public final void join(long millisec ). El hilo
actual invoca este método en un Segundo hilo,
causando que el hilo actual se bloquee hasta
que el Segundo hilo termine o espere el número
de milisegundos pasados.
public final boolean isAlive(). Retorna
true si el hilo esta vivo, lo cual es en cualquier
momento después de que es iniciado pero antes
de que este termine de correr

Los métodos previos son invocados en un
objeto Thread particular.
Los siguientes métodos en la clase Thread son
static. Al invocar uno de los métodos static se
realizan operaciones en el hilo que corre
actualmente:

public static void yield(). Causa que el actual
hilo que esta corriendo ceda ante cualquiera de
los otros hilos con la misma prioridad que
estén esperando para que se ponga en orden
de marcha.
public static void sleep( long millesec ).
Causa que el actual hilo se bloquee por lo
menos el número de milisegundos especificados.

public static boolean holdsLock( Object x).
Retorna true si el hilo actual mantiene un
cerrojo en el Objeto dado. Los cerrojos serán
discutidos en la sección de la palabra clave
synchronized.
public static Thread currentThread().
Retorna una referencia del hilo que esta
corriendo actualmente, lo cual es útil cuando
corremos una aplicación de multihilos paso a
paso.

public static void dumpStack(). Imprime la
pila de trazos del hilo que actualmente esta
corriendo, lo cual es útil para ejecutar paso a
paso una aplicación multihilos.
El siguiente programa ThreadClassDemo
demuestra el uso de algunos de los métodos de
la clase Thread . Esta utiliza las clases
DisplayMessage y GuessANumber.

public class ThreadClassDemo
{
{
Runnable hello = new DisplayMessage("Hello");
Thread thread1 = new Thread(hello);
thread1.setDaemon(true);
thread1.setName("hello");
System.out.println("Starting hello thread...");
thread1.start();

Runnable bye = new DisplayMessage("Goodbye");
Thread thread2 = new Thread(bye);
thread2.setPriority(Thread.MIN_PRIORITY);
thread2.setDaemon(true);
System.out.println("Starting goodbye thread...");
thread2.start();
System.out.println("Starting thread3...");
Thread thread3 = new GuessANumber(27);
thread3.start();

try
{
thread3.join();
}catch(InterruptedException e)
{}
System.out.println("Starting thread4...");
Thread thread4 = new GuessANumber(75);
thread4.start();
System.out.println("main() is ending...");
}
}

Hagamos algunos comentarios sobre el
programa ThreadClassDemo
 Existen un total de cinco hilos involucrados.
( No olvide el hilo que el main() esta
ejecutando.
 Los hilos thread1 y thread2 son hilos
demonios, así que ellos no mantienen el
proceso vivo, lo cual es relevante en este
ejemplo por que el thread1 y el thread2
contienen un bucle infinito.

 Al thread2 se la ha asignado prioridad
mínima.
 El método main() invoca join() en el hilo
thread3, así ellos no mantienen el proceso
vivo, lo cual ocurre en un tiempo indefinido
debido a que el thread3 corre hasta que
adivina el numero 27.

 Mientras el main() esta esperando por el
thread3, existen tres hilos runnable: thread1,
thread2, y thread3.
 Cuando el thread3 termina, el método main()
se convierte en runnable nuevamente e inicia
el thread4. El main() termina y su hilo muere,
dejando que thread1, thread2 y thread4
tengan el resto del tiempo de ejecución del
proceso.

 El thread4 corre hasta que este adivina el
número 75, en este momento solo quedan
dos hilos demonios. Esto causa que el
proceso termine.

Chap 15bpin

Más contenido relacionado

La actualidad más candente (18)

Similar a Chap 15bpin (20)

Último (20)

Chap 15bpin