Hilos

Boris Estiven Palacios

Alarcón

Barranquilla 2010
En la naturaleza se presentan innumerables ejemplos de procesos que se
Realizan de manera parela, simultáneos o concurrentes. Por ejemplo, para
el caso del lector, los procesos que está realizando todo su cuerpo integral,
mientras realiza la acción consciente, de leer este párrafo. En el plano de
los sistemas artificiales, la concurrencia es un denominador común, el
computador, la internet, los juegos, en los sistemas sofisticados de los
automóviles modernos, las actuales comunicaciones inalambricas, etc.
Por tales razones, la concurrencia es un fenómeno importante de tratar, ya
que permite el desarrollo de sistemas capaces de adelantar, múltiples
procesos simultáneamente. A su vez cada proceso se puede componer de
múltiples tareas, ejecutándose según ciertas reglas, de manera simultánea.

Hasta el momento se han desarrollado programas que realizan una sola

tarea, entendiendose por tarea, un hilo de ejecución o un thread, tambien
denominados de flujo único, en contraste con los programas que realizan
más de una tarea, o de multitareas o multithreads, denominados de flujo
múltiple. Especificamente una tarea se encarga de controlar un único
aspecto, dentro de la ejecución de un programa, por ejemplo el manejo de
gráficos, las entradas/salidas de archivos en disco, u otros. Las tareas se
diferencian de los procesos, en que las primeras comparten los mismos
recursos del programa que las contiene, en tanto los procesos tienen en
forma separada su código, así como sus datos.

Se puede definir hilo como una secuencia única de control de flujo dentro
de un programa. Entendiendo que puede haber más de una secuencia de
control o hilos. Java permite realizar programación multihilo, el cual
consiste en programas que contienen dos o más partes que se ejecutan de
manera concurrente. Una parte que se ejecuta independientemente de las
demás se denomina un hilo (thread).
En un entorno de multitarea basada en hilos, el hilo es la unidad de código
más pequeña que se puede seleccionar para ejecución. La programación
basada en multihilos, permite escribir programas más eficientes ya que
optimizan los recursos de la Unidad Central de Proceso (CPU), al reducir al
mínimo los tiempos de inactividad. Este es un factor muy importante a
tener en cuenta en el manejo de entornos interactivos, como es el caso del
trabajo en la red, en dondelas velocidades de transmisión son mucho más
lentas que los requeridos por laCPU en el procesamiento de esos datos, así
como tambien durante el manejo del sistema de archivos, lectura y
grabación, que son más lentos que las velocidades de la CPU en su proceso.
Las animaciones y los juegos por ejemplo, requieren de una mayor
optimización de los recursos de CPU.

La programación multihilo permite acceder a los recursos de tiempo libre

de la CPU, mientras se realizan otras tareas. Es otra de las razones de
importancia para el estudio de sistemas basados en multihilos.

El modelo multihilo está inmerso en el interprete de Java, ya que las

bibliotecas de clases estan diseñadas teniendo en mente este modelo. Los
hilos forman parte de todos los programas en Java. Un hilo dentro de un
programa Java es un procedimiento que se puede ejecutar independiente
del resto de una aplicación.
La siguiente figura ilustra esquemáticamente un programa de un hilo y un
programa de dos hilos.
Ciclo de vida de un hilo
Un hilo tiene un ciclo de vida que va desde su creación hsta su terminación.
Durante su ciclo de vida cada uno de los hilos o tareas de una aplicación
puede estar en diferentes estados, algunos de los cuales se indican a
continuación:
• Nacido: Cuando se acaba de crear un hilo, se dice que está nacido, y
continúa en ese estado hasta que se invoca el método start() del hilo.
La siguiente sentencia crea un nuevo thread pero no lo arranca, por lo
tanto deja el thread en el estado de nacido.
Thread miHilo = new MiClaseThread();
Cuando un thread está en este estado, es sólo un objeto Thread vacío o
nulo. No se han asignado recursos del sistema todavía para el thread.
Así, cuando un thread está en este estado, lo único que se puede hacer
es arrancarlo con start().

•Listo: Cuando se invoca el método start() del hilo, se dice que está en
estado listo. El método se arranca con la siguiente instrucción, para el
caso del hilo miHilo:
miHilo.start();
• Ejecutable:cuando el método start() se ejecuta, crea los recursos del
sistema necesarios para ejecutar el thread, programa el thread para

ejecutarse, y llama al método run() del thread que se ejecuta en

forma secuencial. En este punto el thread está en el estado
ejecutable. Se denomina así puesto que todavía no ha empezado a
ejecutarse.
• En ejecución: Un hilo en estado de listo de la más alta prioridad, pasa al
estado de ejecución, cuando se le asignan los recursos de un
procesador, o sea cuando inicia su ejecución. Aquí el thread está en
ejecución.Cada hilo tiene su prioridad, hilos con alta prioridad se
ejecutan preferencialmente sobre los hilos de baja prioridad.
• No ejecutable :Un hilo continúa la ejecución de su método run(),
hasta
que pasa al estado de no ejecutable originado cuando ocurre alguno
de los siguientes cuatro eventos:
Se invoca a su método sleep().
Se invoca a su su método suspend().
El thread utiliza su método wait() para esperar una condición
variable.
El thread está bloqueado durante una solicitud de entrada/salida.
• Muerto: Un hilo pasa al estado de muerto cuando se termina su método
run(), o cuando se ha invocado su método stop(). En algún momento
el sistema dispondrá entonces del hilo muerto. Un hilo puede morir
de dos
formas:

.Muerte natural: se produce cuando su método run() sale normalmente.

Por ejemplo, el bucle while en este método es un bucle que itera 100
veces y luego sale. Por tanto el hilo morirá naturalmente cuando se
llegue al final de la iteración, es decir se termina su método run().
public void run() {
int i = 0;
while (i < 100) {
i++;
System.out.println("i = " + i);
}
}
Por muerte provocada: en cualquier momento llamando a su método
stop(). El siguiente código crea y arranca miHilo luego lo pone a
dormir durante 10 segundos. Cuando el thread actual se despierta, se
lo mata con miHilo.stop(). El método stop() lanza un objeto
ThreadDeath hacia al hilo a eliminar. El thread moririá cuando reciba
realmente la excepción ThreadDeath.
Thread miHilo = new MiClaseThread();
miHilo.start();
try {
Thread.currentThread().sleep(10000);
} catch (InterruptedException e){
}miHilo.stop();
El método stop() provoca una terminación súbita del método run()
del hilo. Si el método run() estuviera realizando cálculos sensibles,
stop() podría dejar el programa en un estado inconsistente.
Normalmente, no se debería

MULTIHILO Y MULTIPROCESO
Un hilo de ejecucion, en sistemas operativos, es una característica que permite a una aplicación
realizar varias tareas a la vez (concurrentemente). Los distintos hilos de ejecución comparten
una serie de recursos tales como el espacio de memoria, los archivos abiertos, situación de
autenticación, etc. Esta técnica permite simplificar el diseño de una aplicación que debe llevar a
cabo distintas funciones simultáneamente.

Un hilo es básicamente una tarea que puede ser ejecutada en paralelo con otra tarea.

Los hilos de ejecución que comparten los mismos recursos, sumados a estos recursos, son en
conjunto conocidos como un proceso. El hecho de que los hilos de ejecución de un mismo
proceso compartan los recursos hace que cualquiera de estos hilos pueda modificar éstos.
Cuando un hilo modifica un dato en la memoria, los otros hilos acceden a ese dato modificado
inmediatamente.

Lo que es propio de cada hilo es el contador de programa, la pila de ejecución y el estado de

la CPU (incluyendo el valor de los registros).

El proceso sigue en ejecución mientras al menos uno de sus hilos de ejecución siga activo.
Cuando el proceso finaliza, todos sus hilos de ejecución también han terminado. Asimismo en el
momento en el que todos los hilos de ejecución finalizan, el proceso no existe más y todos sus
recursos son liberados.

Diferencia entre Hilo Y Multiproceso

Los hilos se distinguen de los tradicionales procesos en que los procesos son –generalmente–
independientes, llevan bastante información de estados, e interactúan sólo a través
de mecanismos de comunicación dados por el sistema. Por otra parte, muchos hilos
generalmente comparten otros recursos de forma directa. En muchos de los sistemas
operativos que dan facilidades a los hilos, es más rápido cambiar de un hilo a otro dentro del
mismo proceso, que cambiar de un proceso a otro. Este fenómeno se debe a que los hilos
comparten datos y espacios de direcciones, mientras que los procesos, al ser independientes,
no lo hacen. Al cambiar de un proceso a otro el sistema operativo (mediante el dispatcher)
genera lo que se conoce como overhead, que es tiempo desperdiciado por el procesador para
realizar un cambio de contexto (context switch), en este caso pasar del estado de ejecución
(running) al estado de espera (waiting) y colocar el nuevo proceso en ejecución. En los hilos,
como pertenecen a un mismo proceso, al realizar un cambio de hilo el tiempo perdido es casi
despreciable.

Ejercicio Realizado.
Ya la necesidad de usar hilos
package cajatexto;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class cajatexto extends JFrame implements ActionListener {

JButton b1,b2;
TextArea ta;
JPanel p,p2;
public cajatexto() {
b1=new JButton("parpadear");
b1.addActionListener(this);
b2=new JButton("parar");
b2.addActionListener(this);
ta=new TextArea(20,20);
p=new JPanel();
p.setLayout(new BorderLayout());
p.setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
p.add("Center",ta);
p2=new JPanel();
p2.setLayout(new GridLayout(1,2));
p2.add(b1);
p2.add(b2);
p.add("South",p2);

addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent we){

System.exit(0);
}
}
);
setSize(400,400);
setLocation(200,200);
show();
setContentPane(p);
}
public void actionPerformed(ActionEvent ae){
if(ae.getSource()==b1){
for(int i=0;i<100;i++){
if(i%2==0){
ta.setBackground(Color.BLUE);

}
else{
ta.setBackground(Color.RED);
}
}
}
if(ae.getSource()==b2){
ta.setBackground(Color.WHITE);
}
}
public static void main (String[] args) {
new cajatexto();
}