## Un Applet de un Reloj Digital

Este applet muestra la hora actual y la actualiza cada segundo. Puedes moverte por la página o realizar cualquier otra tarea mientras el reloj continua actualizandose porque el código que actualiza el reloj y lo muestra se ejecuta dentro de un thread.

Esta sección explica el código fuente de este applet. En particular, esta página descrbie los segmentos de código que implementa el comportamiento del thread del reloj; no describe el código que está relacionado con el ciclo de vida del applet. Si no has escrito sus propios applets o si no estás familiarizado con el ciclo de vida de una applet, podrías encontrar las respuestas en El ciclo de vida de un Applet antes de proceder con esta página.

### Decidir Utilizar el Interface Runnable

> El applet del reloj utiliza el interface Runnable para proporcionar el método `run()` para su thread. Para ejecutarse dentro de un navegador compatible con Java, la clase Clock debe derivar de la clase Applet. Sin embargo este applet también necesita un thread para poder actualizar continuamente la pantalla sin tomar posesión del proceso en el que se está ejecutando. (Algunos navegadores, pero no todos, crean un nuevo thread para cada applet para impedir que un applet descortés tome posesión del thread principal del navegador. Sin embargo, no deberías contar con esto cuando escribas tus applets; los applets deben crear sus propios threads cuando hagan un trabajo de calculo intensivo). Como el lenguaje Java no soporta la herencia múltiple, la clase Class no puede heredarse desde la clase Thread y de la clase Applet a la vez. Por eso, la clase Clock debe utilizar el interface Runnable para proporcionar el comportamiento de sus thread.

> Los applets no son threads, ni ningún navegador existente -- compatibles con Java o visualizadoes de applets crean threads automáticante en el que ejecutar applets. Por lo tanto, si un applet, necesita un thread debe creárselo el mismo. El applet del reloj necesita un thread en el que realizar las actualizaciones de pantalla porque se actualiza de forma frecuente y el usuario necesita poder realizar otras tareas a la vez que se ejecuta el reloj (como ir a otra página o moverse por ésta).

### El Interface Runnable

> El applet del reloj proporciona un método run() para su thread mediante el interface Runnable. La definición de la lcase Clock indica que es una subclase de la clase Applet y que implementa el interface Runnable. Si no estás familiarizado con los interfaces puedes revisar la información de la lección "Objetos, Clases, e Interfaces"

>     class Clock extends Applet implements Runnable {

> El interface Runnable define un sólo método llamado run() que no acepta ningún argumento y que no devuelve ningún valor. Como la clase Clock implementa el interface Runnable, debe proporcionar una implementación para el método run() como está definido en el interface. Sin embargo, antes de explicar el método run() de la clase Clock, echemos un vistazo a los otros elementos del código de esta clase:

### Crear el Thread

> La aplicación en la que se ejecuta el applet llama al método start() del applet cuando el usuario visita la página del applet. El applet del reloj crea un Thread, clockThread, en su método start() y arranca el thread.

>     public void start() {
>         if (clockThread == null) {
>             clockThread = new Thread(this, "Clock");
>             clockThread.start();
>         }
>     }

> Primero el método start() comprueba si clockThread es nulo. Si lo es, significa que el applet acaba de ser cargado o que ha sido parado anteriormente y se debe crear un nuevo Thread. De otro modo, significa que el applet ya se está ejecutando. El applet crea un nuevo Thread con esta llamada:

>     clockThread = new Thread(this, "Clock");

> Observa que this -- el applet Clock -- es el primer argumento del constructor del thread. El primer argumento de este constructor Thread debe implementar el interface Runnable y se convierte en el origen del thread. Cuando se construye de esta forma, el thread del reloj obtiene su método run() desde el objeto Runnable origen -- en este caso el applet Clock.

> El segundo argumento es sólo el nombre del thread.

### Parar el Thread

> Cuando abandones la página que muestra el Reloj, la aplicación en la que el applet se está ejecutando llama al método stop() del applet. El método stop() del applet Clock pone clockThread a nulo. Esto le dice al bucle principal en el método run() que termine (observa la siguiente sección), la actualización del reloj resultando eventualmente en la parada del thread y la recolección de basura.

>     public void stop() {
>         clockThread = null;
>     }

> Podrías utilizar clockThread.stop() en su lugar, lo que pararía inmediatamente el thread del reloj. Sin embargo, el método stop() de la clase Thread tiene un efecto súbito, lo que significa que el método run() podría estar en medio de una operación crítica cuando se pare el thread. Para los métodos run() más complejos, utilizar el método stop() de la clase Thread podría dejar el programa en un estado incosistente. Por esta razón, es mejor evitar el uso del método stop() de la clase Thread cuando sea posible.

> Si revisita la página de nuevo, se llama otra vez al método start() y el reloj arranca de nuevo con un nuevo thread.

### El Método Run

> Y finalmente, el método run() del applet Clock implementa el corazón de este applet y se parace a esto:

>     public void run() {
>             // El bucle termina cuando clockThread se pone a null en stop()
>         while (Thread.currentThread() == clockThread) {
>             repaint();
>             try {
>                 clockThread.sleep(1000);
>             } catch (InterruptedException e){
>             }
>         }
>     }

> Como se vió en la sección anterior, cuando se le pide al applet que se pare, este selecciona clockThread a null; esto permite que el método run() sepa cuando debe parar. Así, la primera línea del método run() tiene un bucle hasta que clockThread sea nulo. Dentro del bucle, el applet se repinta a sí mismo y le dice al Thread que espere durante 1 segudo (1000 milisegundos). Luego el método repaint() del applet llama al método paint() del applet, que actualiza el área de pantalla del applet. El método paint() de nuestro applet Clock obtiene la hora actual y la muestra en la pantalla:

>     public void paint(Graphics g) {
>         Date now = new Date();
>         g.drawString(now.getHours() + ":" + now.getMinutes() + ":" + now.getSeconds(), 5, 10);
>     }

Ozito