Todos los programadores conocen lo que es un proceso, la mayoria diria que es un programa en ejecucion: tiene un principio, una secuencia de instrucciones y tiene un final.
Un Thread es un flujo simple de ejecucion dentro de un programa. Hasta el momento, todos los programas creados contienen un unico Thread, pero un programa (o proceso) puede iniciar la ejecucion de varios de ellos concurrentemente. Puede parecer que es lo mismo que la ejecucion de varios procesos concurrentemente a modo del FORK() en UNIX, pero existe una diferencia. Mientras en los procesos concurrentes cada uno de ellos dsipone de su propia memoria y contexto, en los Threads lanzados desde un mismo programa, la memoria se comparte utilizando el mismo contexto y recursos asignados al programa (tambien disponen de variables y atributos locales al Thread) .
Un Thread no puede existir independientemente de un programa, sino que se ejecuta dentro de un programa o proceso.
2. Ciclo de vida de un hilo
El ciclo de vida de un Thread puede pasar por varios estados ilustrados en la siguiente figura
Cuando se instancia un Thread, se inicializa sin asignarle recursos. Està en el estado "nuevo Thread" . Un Thread en este estado unicamente acepta las llamdas a los metodos Start() o Stop().
3. Sintaxis de creacion de un hilo
class PrimerThread implements Runnable {
Thread t;
public void start() {
t = new Thread(this);
t.start();
}
public void run() {
int i;
for (i=1;i<=50;i++)
System.out.println(i);
}
}
class SegundoThread extends PrimerThread {
}
class ThreadRunnable {
public static void main(String args[]) {
SegundoThread s = new SegundoThread();
Threads.
206
SegundoThread ss = new SegundoThread();
s.start();
ss.start();
}
}
En este caso se utiliza el constructor de la clase Thread:
public Thread(Runnable destino);
Metodología para la creación del thread:
1) La clase creada debe implementar el interface Runnable:
class PrimerThread implements Runnable {
2) La clase ha de crear un atributo (o variable local en el método start() )
de la clase Thread:
Thread t;
3) Hay que redefinir el método start():
· Instanciar el atributo de la clase Thread llamando a su constructor
pasándole como parámetro la propia instancia de clase (this):
t = new Thread(this);
· Iniciar el thread:
t.start();
4) Redefinir el método run() tal y como se hace en la otra alternativa de
creación de threads (mediante subclases de Thread).
Una vez declarada la clase que implementa la interface Runnable, ya puede ser
instanciada e iniciada como cualquier thread. Es más, cualquier subclase
descendiente de esta clase poseerá también las características propias de los
threads, como ocurre en el ejemplo: SegundoThread es subclase de
PrimerThread, y por lo tanto, ambas son Thread.
4. Clase y metodos de clase que permiten manipular un hilo
Thread().
public static Thread currentThread();
Devuelve el thread que se está ejecutando acutalmente. $ Ver ejemplo en
el punto siguiente.
isAlive().
public final boolean isAlive();
Devuelve false si el thread está en el estado nuevo thread o muerto y
true en caso contrario.
!
class MiThread extends Thread {
public void run() {
try {
sleep(2000);
} catch (InterruptedException e) { }
}
}
join().
public final void join() throws InterruptedException;
Hace que el thread que se está ejecutando actualmente pase al estado
“esperando” indefinidamente hasta que muera el thread sobre el que se
realiza el join().
yield().
public static void yield();
Threads.
210
Transfiere el control al siguiente Thread en el scheduler41 (con la misma
prioridad que el actual) que se encuentre en estado ejecutable.
sleep().
1) public static void sleep(long milisegundos) throws InterruptedException;
2) public static void sleep(long milisegundos, int nanosegundos) throws
InterruptedException;
1) Hace que el thread actual pase del estado ejecutable a dormido y permanezca
en dicho estado durante los milisegundos especificados como parámetro. Una
vez que se ha cumplido el tiempo, el thread “despierta” y pasa
automáticamente al estado de ejecutable.
2) Acepta un parámetro más: un número entero de nanosegundos (0 … 999999 )
que se sumaran a los milisegundos de espera.
5. Para que sirve la interface Runable
La interface Runnable proporciona un método alternativo a la utilización de la clase Thread, para los casos en los que no es posible hacer que la clase definida extienda la clase Thread. Esto ocurre cuando dicha clase, que se desea ejecutar en un hilo independiente deba extender alguna otra clase. Dado que no existe herencia múltiple, la citada clase no puede extender a la vez la clase Thread y otra más. En este caso, la clase debe implantar la interface Runnable, variando ligeramente la forma en que se crean e inician los nuevos hilos.
El siguiente ejemplo es equivalente al del apartado anterior, pero utilizando la interface Runnable:
public class ThreadEjemplo implements Runnable {
public void run() {
for (int i = 0; i < 5 ; i++)
System.out.println(i + " " +
Thread.currentThread().getName());
System.out.println("Termina thread " +
Thread.currentThread().getName());
}
public static void main (String [] args) {
new Thread (new ThreadEjemplo(), "Pepe").start();
new Thread (new ThreadEjemplo(), "Juan").start();
System.out.println("Termina thread main");
}
}
No hay comentarios:
Publicar un comentario