Qu es un Thread?

Todos los programadores estn familiarizados con la escritura de programas secuenciales.

T probablemente hayas escrito un programa que muestre "Hello World!", o que ordene una lista de nombres, o que
calcule la lista de nmeros primos. Estos son programas secuenciales: cada uno tiene un principio, una secuencia de
ejecucin y un final. En un momento dado durante la ejecucin del programa hay un slo punto de ejecucin.
Un Thread es similar a los programas secuenciales descritos arriba: un slo thread tambin tiene un principio, un
final, una secuencia, y en un momento dado durante el tiempo de ejecucin del thread slo hay un punto de
ejecucin. Sin embargo, un thread por si mismo no es un programa. No puede ejecutarse por s mismo, pero si con
un programa.

Definicin:
Un thread es un flujo secuencial de control dentro de un programa.
No hay nada nuevo en el concepto de un slo thread. Pero el juego real alrededor de los threads no est sobre los
threads secuenciales solitarios, sino sobre la posibilidad de que un solo programa ejecute varios threads a la vez y
que realicen diferentes tareas.
El navegador HotJava es un ejemplo de una aplicacin multi-thread. Dentro del navegador HotJava puedes moverte
por la pgina mientras bajas un applet o una imagen, se ejecuta una animacin o escuchas un sonido, imprimes la
pgina en segundo plano mientras descargas una nueva pgina, o ves cmo los tres algoritmos de ordenacin
alcanzan la meta.
Algunos textos utilizan el nombre proceso de poco peso en lugar de thread.
Un thread es similar a un proceso real en el que un thread y un programa en ejecucin son un slo flujo secuencial
de control. Sin embargo, un thread se considera un proceso de poco peso porque se ejecuta dentro del contexto de
un programa completo y se aprovecha de los recursos asignados por ese programa y del entorno de ste.
Como un flujo secuencial de control, un thread debe conseguir algunos de sus propios recursos dentro de un
programa en ejecucin. (Debe tener su propia pila de ejecucin y contador de programa, por ejemplo). El cdigo que
se ejecuta dentro de un Thread trabaja slo en ste contexto. As, algunos texto utilizan el trmino contexto de
ejecucin como un sinnimo para los threads.

Un Sencillo Thread de Ejemplo

Este ejemplo define dos clases: SimpleThread y TwoThreadsTest. Empecemos nuestra exploracin de la aplicacin
con la clase SimpleThread -- una subclase de la clase Thread, que es proporcionada por el paquete java.lang.
class SimpleThread extends Thread {
public SimpleThread(String str) {
super(str);
}
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(i + " " + getName());
try {
sleep((int)(Math.random() * 1000));
} catch (InterruptedException e) {}
}
System.out.println("HECHO! " + getName());
}

El primer mtodo de esta clase es un constructor que toma una cadena como su nico argumento. Este constructor
est implementado mediante una llamada al consturctor de la superclase y es intresante para nosotros slo porque
selecciona el nombre del Thread, que se usar ms adelante en el programa.
El siguiente mtodo es el mtodo run(). Este mtodo es el corazn de cualquier Thread y donde tiene lugar la accin
del Thread. El mtodo run() de la clase SimpleThread contiene un bucle for que itera diez veces. En cada iteracin el
mtodo muestra el nmero de iteracin y el nombre del Thread, luego espera durante un intervalo aleatorio de hasta
1 segundo. Despus de haber temrinado el bucle, el mtodo run() imprime "HECHO!" con el nombre del Thread.
La clase TwoThreads proporciona un mtodo main() que crea dos threads SimpleThread: uno llamado "Jamaica" y
otro llamadao "Fiji". (Si no quieres decidir donde ir de vacaciones puedes utilizar este programa para ayudarte a
elegir -- ve a la isla cuyo threads imprima "HECHO!" primero).
class TwoThreadsTest {
public static void main (String[] args) {
new SimpleThread("Jamaica").start();
new SimpleThread("Fiji").start();
}
}

El mtodo main() tambin arranca cada uno de los threads inmediatamente despus siguiendo su construccin con
una llamada al mtodo start(). El programa dara una salida parecida a esta.
0 Jamaica
0 Fiji
1 Fiji
1 Jamaica
2 Jamaica
2 Fiji
3 Fiji
3 Jamaica
4 Jamaica
4 Fiji
5 Jamaica
5 Fiji
6 Fiji
6 Jamaica
7 Jamaica
7 Fiji
8 Fiji
9 Fiji
8 Jamaica
HECHO! Fiji
9 Jamaica
HECHO! Jamaica

Observa cmo la salida de cada uno de los threads se mezcla con la salida del otro. Esto es porque los dos threads
SimpleThread se estn ejecutando de forma concurrente. As, los dos mtodos run() se stn ejecutando al mismo
tiempo y cada thread est mostrndo su salida al mismo tiempo que el otro.
Prueba esto: Modifica el programa principal y crea un tercer Thread llamado "Bora Bora".
Compila el programa y ejectalo de nuevo. Ha cambiado la isla de destino de tus vacaciones?

Atrributos de un Thread

Por ahora, te has familiarizado con los threads y has visto un sencillo programa Java que ejecuta dos thread
concurrentemente. Esta pgina presenta varias caractersticas especficas de los threads Java y proporciona enlaces
a las pginas que explican cada caracterstica con ms detalle.
Los thredas java estn implementados por la clase Thread, que es una parte del paquete java.lang.
Esta clase implementa una definicin de threads independiente del sistema. Pero bajo la campana, la
implementacin real de la operacin concurrente la proporciona una implementacin especfica del sistema. Para la
mayora de las aplicaciones, la implementacin bsica no importa. Se puede ignorar la implementacin bsica y
programar el API de los thread descrito en estas lecciones y en otra documentacin proporcionada con el sistema
Java.
Cuerpo del Thread
Toda la accin tiene lugar en el cuerpo del thread -- el mtodo run().
Se puede proporcionar el cuerpo de un Thread de una de estas dos formas: subclasificando la clase Thread
y sobreescribiendo su mtodo run(), o creando un thread con un objeto de la clase Runnable y su target.
Estado de un Thread
A lo largo de su vida, un thread tiene uno o varios estados. El estado de un thread indica qu est haciendo
el Thread y lo que es capaz de hacer durante su tiempo de vida.
se est ejecutando?, est esperando? o est muerto?
La prioridad de un Thread
Una prioridad del Thread le dice al temporizador de threads de Java cuando se debe ejecutar este thread en
relacin con los otros.
Threads Daemon
Estos threads son aquellos que porporcionan un servicio para otros threads del sistema.
Cualquier thread Java puede ser un thread daemon.
Grupos de Threads
Todos los threads pertenecen a un grupo. La clase ThreadGrpup, perteneciente al paquete java.lang define
e implementa las capacidades de un grupo de thread relacionados.

El Cuerpo de un Thread
Toda la accin tiene lugar en el cuerpo del thread, que es el mtodo run() del thread. Despus de crear e inicializar
un thread, el sistema de ejecucin llama a su mtodo run(). El cdigo de este mtodo implementa el comportamiento
para el que fue creado el thread. Es la razn de existir del thread.
Frecuentemente, el mtodo run() de un thread es un bucle. Por ejemplo, un thread de animacin podra iterar a
travs de un bucle y mostrar una serie de imgenes. Algunas veces un mtodo run() realiza una operacin que tarda
mucho tiempo, como descargar y ejecutar un sonido o una pelcula JPEG.
Puedes elegir una de estas dos formas para proporcionar un mtodo run() a un thread Java.
1.

Crear una subclase de la clase Thread definida en el paquete java.lang y sobreescribir el mtodo run().
Ejemplo: La clase SimpleThread descrita en En ejemplo sencillo de Thread.

2.

Proporcionar una clase que implemente el interface Runnable, tambin definido en el paquete java.lang.
Ahora, cuando se ejemplarice un thread (bien directamente desde la clase Thread o desde una de sus
subclases), dale al nuevo thread un manejador a un ejemplar de la clase Runnable. Este objeto Runnable
proporciona el mtodo run() para el thread.

El Estado de un Thread
El siguiente diagrama ilustra los distintos estados que puede tener un Thread Java en cualquier momento de su vida.
Tambin ilustra las llamadas a mtodos que provocan las transiciones de un estado a otro. Este no es un diagrama
de estado finito pero da un idea general del las facetas ms interesantes y comunes en la vida de un thread. El resto
de est pgina explica el ciclo de vida de un thread, basndose en sus estados.

Un "Nuevo Thread"
La siguiente sentencia crea un nuevo thread pero no lo arranca, por lo tanto deja el thread en el estado : "New
Thread" = "Nuevo Thread".
Thread miThread = new MiClaseThread();

Cuando un thread est en este estado, es slo un objeto Thread vaco. No se han asignado recursos del sistema
todava para el thread. As, cuando un thread est en este estado, lo nico que se puede hacer es arrancarlo o
pararlo. Llamar a otros mtodos distintos de start() o stop() no tiene sentido y causa una excepcin del tipo
IllegalThreadStateException.

Ejecutable
Ahora consideremos estas dos lneas de cdigo.
Thread miThread = new MiClaseThread();
miThread.start();

Cuando el mtodo start() crea los recursos del sistema necesarios para ejecutar el thread, programa el thread para
ejecutarse, y llama al mtodo run() del thread. En este punto el thread est en el estado "Ejecutable". Este estado se
llama "Ejecutable" mejor que "Ejecutando" ya que el thread todava no ha empezado a ejecutarse cuando est en

este estado. Muchos procesadores tienen un slo procesador, haciendo posible que todos los threads sean
"Ejecutables" al mismo tiempo. Por eso, el sistema de ejecucin de Java debe implementar un esquema de
programacin para compartir el procesador entre todos los threads "Ejecutables".
(Puedes ver la pgina Prioridad de un Thread para obtener ms informacin sobre la programacin.) Sin embargo,
para la mayora de los propositos puedes pensar en "Ejecutable" como un sencillo "Ejecutando". Cuando un thread
se est ejecutanto -- est "Ejecutable" y es el thread actual -- las instrucciones de su mtodo run()se ejecutan de
forma secuencial.

No Ejecutable
Un thread entra en el estado "No Ejecutable" cuando ocurre uno de estos cuatro eventos.

Alguien llama a su mtodo sleep().

Alguien llama a su mtodo suspend().

El thread utiliza su mtodo wait() para esperar una condicin variable.

El thread est bloqueado durante la I/O.

Por ejemplo, la lnea en negrita del siguiente fragmento de codigo pone a dormir miThread durante 10 segundos
(10.000 milisegundos).
Thread miThread = new MiClaseThread();
miThread.start();
try {
miThread.sleep(10000);
} catch (InterruptedException e){
}

Durante los 10 segundos que miThread est dormido, incluso si el proceso se vuelve disponible miThread no se
ejecuta. Despus de 10 segundos, miThread se convierte en "Ejecutable" de nuevo y, si el procesar est disponible
se ejecuta.
Para cada entrada en el estado "No Ejecutable" mostrado en figura, existe una ruta de escape distinta y especfica
que devuelve el thread al estado "Ejecutable". Una ruta de escape slo trabaja para su entrada correspondiente. Por
ejemplo, si un thread ha sido puesto a dormir dutante un cierto nmero de milisegundos deben pasar esos
milisegundos antes de volverse "Ejecutable" de nuevo.
Llamar al mtodo resume() en un thread dormido no tiene efecto.
Esta lista indica la ruta de escape para cada entrada en el estado "No Ejecutable".

Si se ha puesto a dormir un thread, deben pasar el nmero de milisegundos especificados.

Si se ha suspendido un thread, alguien debe llamar a su mtodo resume().

Si un thread est esperando una condicin variable, siempre que el objeto propietario de la variable
renuncie mediante notify() o notifyAll().

Si un thread est bloqueado durante la I/O, cuando se complete la I/O.

Muerto

Un thread puede morir de dos formas: por causas naturares o siendo asesinado (parado). Una muerte natural se
produce cuando su mtodo run() sale normalmente. Por ejemplo, el bucle while en este mtodo es un bucle finito -itera 100 veces y luego sale.
public void run() {
int i = 0;
while (i < 100) {
i++;
System.out.println("i = " + i);
}
}

Un thread con este mtodo run() morira natualmente despus de que el bucle y el mtodo run() se hubieran
completado.
Tambin puede matar un thread en cualquier momento llamando a su mtodo stop(). El siguiente cdigo crea y
arranca miThread luego lo pone a dormir durante 10 segundos. Cuando el thread actual se despierta, la lnea en
negrita mata miThread.
Thread miThread = new MiClaseThread();
miThread.start();
try {
Thread.currentThread().sleep(10000);
} catch (InterruptedException e){
}miThread.stop();

El mtodo stop() lanza un objeto ThreadDeath hacia al thread a eliminar. As, cuando se mata al thread de esta
forma, muere de forma asncrona. El thread moriri cuando reciba realmente la excepcin ThreadDeath.
El mtodo stop() provoca una terminacin sbita del mtodo run() del thread. Si el mtodo run() estuviera realizando
clculos sensibles, stop() podra dejar el programa en un estado inconsistente. Normalmente, no se debera llamar al
mtodo stop() pero si se debera proporcionar una terminacin educada como la seleccin de una bandera que
indique que el mtodo run() debera salir.

La Excepcin IllegalThreadStateException
El sistema de ejecucin lanza una excepcin IllegalThreadStateException cuando llama a un mtodo en un thread y
el estado del thread no pemmite esa llamada a mtodo.
Por ejemplo, esta excepcin se lanza cuando se llama a suspend() en un thread que no est "Ejecutable".
Como se ha mostrado en varios ejemplos de threads en est leccin, cuando se llame a un mtodo de un thread que
pueda lanzar una excepcin, se debe capturar y manejar la excepcin, o especificar al mtodo llamador que se lanza
la excepcin no capturada. Puedes ver la informacin sobre el manejo de excepciones en Java en Excepciones

El Mtodo isAlive()
Una ltima palabra sobre el estrado del thread: el interface de programacin de la clase Thread incluye un mtodo
llamado isAlive(). Este mtodo devuelve true si el thread ha sido arrancado y no ha parado. As, si el mtodo
isAlive() devuelve false sabrs que se trata de un "Nuevo thread" o de un thread "Muerto". Por el contrario si
devuelve true sabrs que el thread es "Ejecutable" o "No Ejecutable". No se puede diferenciar entre un "Nuevo
thread" y un thread "Muerto", como tampoco se puede hacer entre un thread "Ejecutable" y otro "No Ejecutable"

Prioridad de un Thread
Anteriormente en esta leccin , hemos reclamado que los applets se ejecuten de forma concurrente.

Mientras conceptualmente esto es cierto, en la prctica no lo es. La mayora de las configuraciones de ordenadores
slo tienen una CPU, por eso los threads realmente se ejecutan de uno en uno de forma que proporcionan una
ilusin de concurrencia. La ejecucin de varios threads en una sola CPU, en algunos rdenes, es llamada
programacin.
El sistema de ejecucin de Java soporta un algoritmo de programacin deterministico muy sencillo conocido como
programacin de prioridad fija.Este algoritmo programa los threads basndose en su prioridad relativa a otros threads
"Ejecutables".
Cuando se crea un thread Java, hereda su prioridad desde el thread que lo ha creado. Tambin se puede modificar la
prioridad de un thread en cualquier momento despus de su creaccin utilizando el mtodo setPriority(). Las
prioridades de un thread son un rango de enteros entre MIN_PRIORITY y MAX_PRIORITY (constantes definidas en
la clase Thread). El entero ms alto, es la prioridad ms alta. En un momento dado, cuando varios threads est listos
para ser ejecutados, el sistema de ejecucin elige aquellos thread "Ejecutables" con la prioridad ms alta para su
ejecucin. Slo cuando el thread se para, abandona o se convierte en "No Ejecutable" por alguna razn empezar su
ejecucin un thread con prioridad inferior. Si dos threads con la misma prioridad estn esperando por la CPU, el
programador elige uno de ellos en una forma de competicin. El thread elegido se ejecutar hasta que ocurra alguna
de las siguientes condiciones.

Un thread con prioridad superior se vuelve "Ejecutable".

Abandona, o su mtodo run() sale.

En sistemas que soportan tiempo-compartido, su tiempo ha expirado.

Luego el segundo thread tiene una oprtunidad para ejecutarse, y as continuamente hasta que el interprete
abandone.
El algoritmo de programacin de threads del sistema de ejecucin de Java tambin es preemptivo. Si en cualquier
momento un thread con prioridad superior que todos los dems se vuelve "Ejecutable", el sistema elige el nuevo
thread con prioridad ms alta.
Se dice que el thread con prioridad superior prevalece sobre los otros threads.

Regla del Pulgar:

En un momento dado, el thread con prioridad superior se est ejecutando. Sin
embargo, este no es una garanta. El programador de threads podra elegir otro thread
con prioridad inferior para evitar el hambre. Por esta razn, el uso de las prioridades
slo afecta a la politica del programador para propsitos de eficiencia. No dependas de
la prioridad de los threads para algoritmos incorrectos.
La carrera de Threads
Este cdigo fuente Java implementa un applet que anima una carrera entre dos threads "corredores" con diferentes
prioridades. Cuando pulses con el ratn sobre el applet, arrancan los dos corredores. El corredor superior , llamado
"2", tiene una prioridad 2.
El segundo corredor, llamado "3", tiene una prioridad 3.
Prueba esto: Pulsa sobre el applet inferior para iniciar la carrera.
Este es el mtodo run() para los dos corredores.

public int tick = 1;

public void run() {
while (tick < 400000) {
tick++;
}
}

Este mtodo slo cuenta desde 1 hasta 400.000. La variable tick es pblica porque la utiliza el applet para
determinar cuanto ha progresado el corredor (cmo de larga es su lnea).
Adems de los dos threads corredores, el applet tiene un tercer thread que controla el dibujo.
El mtodo run() de este thread contiene un bucle infinito; durante cada iteracin del bucle dibuja una lnea para cada
corredor (cuya longitud se calcula mediante la variable tick), y luego duerme durante 10 milisegundos. Este thread
tiene una prioridad de 4 -- superior que la de los corredores. Por eso, siempre que se despierte cada 10
milisegundos, se convierte en el thread de mayor prioridad, prevalece sobre el thread que se est ejecutando, y
dibuja las lneas.
Se puede ver cmo las lneas van atravesando la pgina.
Como puedes ver, esto no es una carrera justa porque un corredor tiene ms prioridad que el otro.
Cada vez que el thread que dibuja abandona la CPU para irse a dormir durante 10 milisegundos, el programador
elige el thread ejecutable con una prioridad superior; en este caso, siempre ser el corredor llamado "3". Aqu tienes
otra versin del applet que implementa una carrera justa, esto es, los dos corredores tienen la misma prioridad y
tienen las mismas posibilidades para ser elegidos.
Prueba esto: Pulsa sobre el Applet para iniciar la carrera.
En esta carrera, cada vez que el thread de dibujo abandona la CPU, hay dos threads ejecutables con igual prioridad
-- los corredores -- esperando por la CPU; el programador debe elegir uno de los threads. En esta situacin, el
programador elige el siguiente thread en una especie de competicin deportiva.

Threads Egoistas
La clase Runner utilizada en las carreras anteriores realmente implementea un comportamiendo "socialmenteperjudicioso". Recuerda el mtodo run() de la clase Runner utilizado en las carreras.
public int tick = 1;
public void run() {
while (tick < 400000) {
tick++;
}
}

El bucle while del mtodo run() est en un mtodo ajustado.

Esto es, una vez que el programador elige un thread con este cuerpo de thread para su ejecucin, el thread nunca
abandona voluntariamente el control de la CPU -- el thread se contina ejecutando hasta que el bucle while termina
naturalmente o hasta que el thread es superado por un thread con prioridad superior.
En algunas situaciones, tener threads "egoistas" no causa ningn problema porque prevalencen los threads con
prioridad superior (como el thread del dibujo prevalece sobres los threads egoistas de los corredores. Sin embargo,
en otras situaciones, los threads con mtodos run() avariciosos de CPU, como los de la clase Runner, pueden tomar
posesin de la CPU haciendo que otros threads esperen por mucho tiempo antes de obtener una oportunidad para
ejecutarse.

Tiempo-Compartido
En sistemas, como Windows 95, la lucha contra el comportamiento egoista de los threads tiene una estrategia
conocida como tiempo-compartido. Esta estrategia entra en juego cuando existen varios threads "Ejecutables" con
igual prioridad y estos threads son los que tienen una prioridad mayor de los que estn compitiendo por la CPU. Por
ejemplo, este programa Java (que est basado en la carrera de Applets anterior) crea dos threads egoistas con la
misma prioridad que tienen el siguiente todo run().
public void run() {
while (tick < 400000) {
tick++;
if ((tick % 50000) == 0) {
System.out.println("Thread #" + num + ", tick = " + tick);
}
}
}

Este mtodo contiene un bucle ajustado que incrementa el entero tick y cada 50.000 ticks imprime el indentificador
del thread y su contador tick.
Cuando se ejecuta el programa en un sistema con tiempo-compartido, vers los mensajes de los dos threads,
intermitentemente uno y otro. Como esto.
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread

#1,
#0,
#0,
#1,
#1,
#1,
#0,
#0,
#1,
#0,
#0,
#1,
#1,
#0,
#0,
#1,

tick
tick
tick
tick
tick
tick
tick
tick
tick
tick
tick
tick
tick
tick
tick
tick

=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=

50000
50000
100000
100000
150000
200000
150000
200000
250000
250000
300000
300000
350000
350000
400000
400000

Esto es porque un sistema de tiempo compartido divide la CPU en espacios de tiempo e iterativamente le da a cada
thread con prioridad superior un espacio de tiempo para ejecutarse. El sistema de tiempo compartido itera a travs
de los threads con la misma prioridad superior otorgndoles un pequeo espacio de tiempo para que se ejecuten,
hasta que uno o ms de estos threads finalizan, o hasta que aparezca un thread con prioridad superior. Observa que
el tiempo compartido no ofrece garantias sobre la frecuencia y el orden en que se van a ejecutar los threads.
Cuando ejecutes este programa en un sistema sin tiempo compartido, sin embargo, veras que los mensajes de un
thread terminan de imprimierse antes de que el otro tenga una oportunidad de mostrar un slo mensaje. Como esto.
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread
Thread

#0,
#0,
#0,
#0,
#0,
#0,
#0,
#0,
#1,
#1,
#1,
#1,
#1,

tick
tick
tick
tick
tick
tick
tick
tick
tick
tick
tick
tick
tick

=
=
=
=
=
=
=
=
=
=
=
=
=

50000
100000
150000
200000
250000
300000
350000
400000
50000
100000
150000
200000
250000

Thread #1, tick = 300000

Thread #1, tick = 350000
Thread #1, tick = 400000

Esto es porque el sistema sin tiempo compartido elige uno de los threads con igual prioridad para ejecutarlo y le
permite ejecutarse hasta que abandone la CPU o hasta que aparezca un thread con prioridad superior.

Nota:
El sistema de ejecucin Java no implementa (y por lo tanto no garantiza) el tiempo
compartido. Sin embargo, algunos sistemas en los que se puede ejecutar Java si
soportan el tiempo compartido. Los programas Java no deberan ser relativos al tiempo
compartido ya que podran producir resultados diferentes en distintos sistemas.
Prueba esto: Compila y ejecuta las clases RaceTest y SelfishRunner en tu ordenador. Puedes decir si su sistema
tiene tiempo compartido?
Como te puedes imaginar, escribir cdigo que haga un uso intensivo de la CPU puede tener repercusiones negativas
en otros threads que se ejecutan en el mismo proceso. En general, se debera intentar escribir threads con "buen
comportamiento" que abandonen voluntariamente la CPU de forma peridica y le den una oportunidad a otros
threads para que se ejecuten.
En particular, no escribas nunca cdigo Java que trate con tiempo compartido-- esto garantiza prcticamente que tu
programa dar diferentes resultados en distintos sistemas de ordenador.
Un thread puede abandonar la CPU (sin ir a dormir o algn otro mtodo drstico) con una llamada al mtodo yield().
Este mtodo da una oportunidad a otros threads con la misma prioridad. Si no existen otros threads con la misma
prioridad en el estado "ejecutable", este mtodo ser ignorado.
Prueba esto: Reescribe la clase SelfishRunner para que sea un PoliteRunner "Corredor Educado" mediante una
llamada al mtodo yield() desde el mtodo run().
Asegurese de modificar el programa principal para crear PoliteRunners en vez de SelfishRunners. Compila y ejecuta
las nuevas clases en tu ordenador. No est mejor ahora?

Sumario

La mayora de los ordenadores slo tienen una CPU, los threads deben compartir la CPU con otros threads.
La ejecucin de varios threas en un slo CPU, en cualquier orden, se llama programacin. El sistema de
ejecucin Java soporta un algoritmo de programacin determinstico que es conocido como programacin
de prioridad fija.

A cada thread Java se le da una prioridad numrica entre MIN_PRIORITY y MAX_PRIORITY (constantes
definidas en la clase Thread). En un momento dato, cuando varios threads estn listos para ejecutarse, el
thread con prioridad superior ser el elegido para su ejecucin.
Slo cuando el thread para o se suspende por alguna razn, se empezar a ejecutar un thread con
priporidad inferior.

La programacin de la CPU es totalmente preemptiva. Si un thread con prioridad superior que el que se est
ejecutando actualmente necesita ejecutarse, toma inmediatamente posesin del control sobre la CPU.

El sistema de ejecucin de Java no hace abandonar a un thread el control de la CPU por otro thread con la
misma prioridad. En otras palabras, el sistema de ejecucin de Java no comparte el tiempo. Sin embargo,
algunos sistemas si lo soportan por lo que no se debe escribir cdigo que est relacionado con el tiempo
compartido.

Adems, un thread cualquiera, en cualquier momento, puede ceder el control de la CPU llamando al mtodo
yield(). Los threads slo pueden 'prestar' la CPU a otros threads con la misma priorida que l -- intentar
cederle la CPU a un thread con prioridad inferior no tendr ningn efecto.

Cuando todos los threads "ejecutables" del sistema tienen la misma prioridad, el programador elige a uno de
ellos en una especie de orden de competicin.