¿Cómo funciona el hilo de envío de eventos?

Question

Con la ayuda de las personas en stackoverflow pude obtener el siguiente código de funcionamiento de una cuenta regresiva simple de GUI (que solo muestra una ventana que cuenta en segundos). Mi principal problema con este código es el material invokeLater.

Por lo que entiendo invokeLater, envía una tarea a la cadena de distribución de eventos (EDT) y luego la EDT ejecuta esta tarea siempre que "pueda" (lo que sea que eso signifique). ¿Es correcto?

A mi entender, el código funciona así:

1. En el método maininvokeLater utilizamos para mostrar la ventana (showGUI método). En otras palabras, el código que muestra la ventana se ejecutará en el EDT.

2. En el método main también iniciar el counter y el contador (por construcción) se ejecuta en otro hilo (lo que no es en el hilo del despacho de eventos). ¿Derecha?

3. La counter se ejecuta en una secuencia separada y periódicamente llama a updateGUI. updateGUI se supone que debe actualizar la GUI. Y la GUI está trabajando en el EDT. Por lo tanto, updateGUI también se debe ejecutar en el EDT. Es la razón por la cual el código para updateGUI está encerrado en invokeLater. ¿Está bien?

Lo que no me queda claro es por eso que llamamos el counter de la EDT. De todos modos, no se ejecuta en el EDT. Comienza inmediatamente, se ejecuta un nuevo hilo y el counter allí. Entonces, ¿por qué no podemos llamar al counter en el método principal después del bloque invokeLater?

import javax.swing.JFrame; 
import javax.swing.JLabel; 
import javax.swing.SwingUtilities; 

public class CountdownNew { 

    static JLabel label; 

    // Method which defines the appearance of the window. 
    public static void showGUI() { 
     JFrame frame = new JFrame("Simple Countdown"); 
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     label = new JLabel("Some Text"); 
     frame.add(label); 
     frame.pack(); 
     frame.setVisible(true); 
    } 

    // Define a new thread in which the countdown is counting down. 
    public static Thread counter = new Thread() { 
     public void run() { 
      for (int i=10; i>0; i=i-1) { 
       updateGUI(i,label); 
       try {Thread.sleep(1000);} catch(InterruptedException e) {}; 
      } 
     } 
    }; 

    // A method which updates GUI (sets a new value of JLabel). 
    private static void updateGUI(final int i, final JLabel label) { 
     SwingUtilities.invokeLater( 
      new Runnable() { 
       public void run() { 
        label.setText("You have " + i + " seconds."); 
       } 
      } 
     ); 
    } 

    public static void main(String[] args) { 
     SwingUtilities.invokeLater(new Runnable() { 
      public void run() { 
       showGUI(); 
       counter.start(); 
      } 
     }); 
    } 

} 

Answer 1

Si entiendo bien su pregunta usted es de extrañar por qué no se puede hacer esto:

public static void main(String[] args) { 
    SwingUtilities.invokeLater(new Runnable() { 
     public void run() { 
      showGUI(); 
     } 
    }); 
    counter.start(); 
} 

La razón por la cual no se puede hacer es porque el programador no ofrece ninguna garantía ... sólo porque Invocó showGUI() y luego invocó counter.start() no significa que el código en showGUI() se ejecutará antes que el código en el método de ejecución counter.

creo que de esta manera:

• invokeLater inicia un hilo y ese hilo es programa un evento asíncrono en el EDT, que se encarga de la creación de la JLabel.
• el contador es un hilo separado que depende de la JLabel que existe lo que se puede llamar label.setText("You have " + i + " seconds.");

Ahora usted tiene una condición de carrera:JLabel deben crearse antes de las counter inicios de rosca, si no está creado antes de que comience el subproceso de contador, su subproceso de contador llamará al setText en un objeto no inicializado.

Con el fin de asegurar que la condición de carrera se elimina tenemos que garantizar el orden de ejecución y una manera para garantizarlo es ejecutar showGUI() y counter.start() secuencialmente en el mismo subproceso:

public static void main(String[] args) { 
    SwingUtilities.invokeLater(new Runnable() { 
     public void run() { 
      showGUI(); 
      counter.start(); 
     } 
    }); 
} 

Ahora showGUI(); y counter.start(); se ejecutan desde el mismo subproceso, por lo tanto, se creará el JLabel antes de que se inicie el counter.

Actualización:

Q:Y no entiendo qué tiene de especial este hilo.
A: El código de manejo de eventos de Swing se ejecuta en un hilo especial conocido como el hilo de envío de eventos. La mayoría del código que invoca los métodos de Swing también se ejecuta en este hilo. Esto es necesario porque la mayoría de los métodos de objetos Swing no son "seguros para la ejecución de subprocesos": al invocarlos desde múltiples subprocesos se corre el riesgo de interferencia de subprocesos o errores de coherencia de memoria. 1

Q:Por lo tanto, si tenemos una interfaz gráfica de usuario ¿Por qué debemos iniciarlo en un hilo separado?
A: Probablemente haya una mejor respuesta que la mía, pero si desea actualizar la GUI desde el EDT (que lo hace), entonces debe iniciarlo desde el EDT.

Q:¿Y por qué no podemos simplemente comenzar el hilo como cualquier otro hilo?
A: Ver respuesta anterior.

Q:Por qué utilizamos algunos invokeLater y por qué este hilo (EDT) comienza a ejecutar la solicitud cuando está listo. ¿Por qué no siempre está listo?
A: El EDT podría tener otros eventos AWT que deba procesar. invokeLater Hace que doRun.run() se ejecute de forma asincrónica en el subproceso AWT que distribuye el evento.Esto sucederá después de que se hayan procesado todos los eventos pendientes de AWT. Este método se debe usar cuando un subproceso de aplicación necesita actualizar la GUI. 2

Answer 2

en realidad se está empezando la counter hilo de la EDT. Si llamó al counter.start() después del bloque invokeLater, es probable que el contador comience a ejecutarse antes de y la GUI se vuelva visible. Ahora, porque está construyendo la GUI en el EDT, la GUI no existirá cuando el counter comience a actualizarla. Afortunadamente parece que reenvía las actualizaciones de la GUI al EDT, lo cual es correcto, y dado que EventQueue es una cola, la primera actualización se realizará una vez que se haya construido la GUI, por lo que no debería haber ninguna razón para que esto no funcione. ¿Pero cuál es el punto de actualizar una GUI que puede no ser visible todavía?

Answer 3

¿Cuál es el EDT?

Es una solución hacky torno a la gran cantidad de problemas de concurrencia que el API Swing tiene;)

En serio, una gran cantidad de componentes Swing no son "hilo de seguridad" (algunos programadores famosos fueron tan lejos como llamar oscilación "hilo hostil"). Al tener un hilo único donde se realizan todas las actualizaciones a estos componentes hostiles, se está eludiendo una gran cantidad de posibles problemas de concurrencia. Además de eso, también se le garantiza que ejecutará el Runnable que pase a través de él usando invokeLater en un orden secuencial.

Entonces algunos peros:

public static void main(String[] args) { 
    SwingUtilities.invokeLater(new Runnable() { 
     public void run() { 
      showGUI(); 
      counter.start(); 
     } 
    }); 
} 

Y luego:

En el método principal que también iniciar el contador y el contador (por construcción) se ejecuta en otro hilo (por lo no está en el evento envío de hilo). ¿Derecha?

Realmente no enciende el contador en el método principal. Inicia el contador en el método run() del anónimo Runnable que se ejecuta en el EDT. Entonces realmente comienza el contador Thread del EDT, no es el método principal. Entonces, como se trata de un subproceso separado, no es ejecutar en el EDT. Pero el contador definitivamente es iniciado en el EDT, no en el Thread ejecutando el método main(...).

Es quisquilloso, pero sigue siendo importante visto la pregunta, creo.

Answer 4

Esto es simple, es como sigue

Paso 1. El hilo inicial también llamado hilo principal se crea.

Paso 2. Cree un objeto ejecutable y páselo a invokeLate().

Paso 3. Esto inicializa la GUI pero no crea la GUI.

Paso 4. InvokeLater() planifica el objeto creado para su ejecución en EDT.

Paso 5. Se ha creado GUI.

Paso 6. Todos los eventos que ocurran se colocarán en EDT.