Tutorial de Java - Flujo en Programas

Un programa de flujo único o mono-hilvanado (single-thread) utiliza un único flujo de control (thread) para controlar su ejecución. Muchos programas no necesitan la potencia o utilidad de múltiples flujos de control. Sin necesidad de especificar explícitamente que se quiere un único flujo de control, muchos de los applets y aplicaciones son de flujo único.

Por ejemplo, en nuestra aplicación estándar de saludo:

public class HolaMundo {
     static public void main( String args[] ) {
         System.out.println( "Hola Mundo!" );
         }
     }
 

Aquí, cuando se llama a main(), la aplicación imprime el mensaje y termina. Esto ocurre dentro de un único thread.

En nuestra aplicación de saludo, no vemos el thread que ejecuta nuestro programa. Sin embargo, Java posibilita la creación y control de threads explícitamente. La utilización de threads en Java, permite una enorme flexibilidad a los programadores a la hora de plantearse el desarrollo de aplicaciones. La simplicidad para crear, configurar y ejecutar threads, permite que se puedan implementar muy poderosas y portables aplicaciones/applets que no se puede con otros lenguajes de tercera generación. En un lenguaje orientado a Internet como es Java, esta herramienta es vital.

Si se ha utilizado un navegador con soporte Java, ya se habrá visto el uso de múltiples threads en Java. Habrá observado que dos applet se pueden ejecutar al mismo tiempo, o que puede desplazar la página del navegador mientras el applet continúa ejecutándose. Esto no significa que el applet utilice múltiples threads, sino que el navegador es multithreaded.

Las aplicaciones (y applets) multithreaded utilizan muchos contextos de ejecución para cumplir su trabajo. Hacen uso del hecho de que muchas tareas contienen subtareas distintas e independientes. Se puede utilizar un thread para cada subtarea.

Mientras que los programas de flujo único pueden realizar su tarea ejecutando las subtareas secuencialmente, un programa multithreaded permite que cada thread comience y termine tan pronto como sea posible. Este comportamiento presenta una mejor respuesta a la entrada en tiempo real.

Vamos a modificar nuestro programa de saludo creando tres threads individuales, que imprimen cada uno de ellos su propio mensaje de saludo, MultiHola.java:

// Definimos unos sencillos threads. Se detendrán un rato
 // antes de imprimir sus nombres y retardos
 
 class TestTh extends Thread {
     private String nombre;
     private int retardo;
 
     // Constructor para almacenar nuestro nombre
     // y el retardo
     public TestTh( String s,int d ) {
         nombre = s;
         retardo = d;
         }
 
     // El metodo run() es similar al main(), pero para
     // threads. Cuando run() termina el thread muere
     public void run() {
         // Retasamos la ejecución el tiempo especificado
         try {
             sleep( retardo );
         } catch( InterruptedException e ) {
             ;
             }
 
         // Ahora imprimimos el nombre
         System.out.println( "Hola Mundo! "+nombre+" "+retardo );
         }
     }
 
 public class MultiHola {
     public static void main( String args[] ) {
         TestTh t1,t2,t3;
 
         // Creamos los threads
         t1 = new TestTh( "Thread 1",(int)(Math.random()*2000) );
         t2 = new TestTh( "Thread 2",(int)(Math.random()*2000) );
         t3 = new TestTh( "Thread 3",(int)(Math.random()*2000) );
 
         // Arrancamos los threads
         t1.start();
         t2.start();
         t3.start();
         }
     }
 

Y ya mßs como espectáculo que otra cosa, aunque también podemos tomarlo por el lado ilustrativo, vemos a continuación la elecución del applet Figuras.java que muestra un montón de círculos, cada uno de ellos ejecutándose en un thread diferente y con distinta prioridad cada uno de ellos. La clase Circulo es la que se utiliza para lanzarla todas las veces que se quiere, de tal forma que cada uno de los círculos presentes en el applet son instancias de la misma clase Circulo.