Asynchronous Updates
La API Environment.runLater() proporciona un mecanismo para actualizar de manera segura la interfaz de usuario desde hilos de fondo en aplicaciones webforJ. Esta característica experimental permite operaciones asincrónicas mientras se mantiene la seguridad de los hilos para las modificaciones de la interfaz de usuario.
The webforj-handling-timers-and-async skill can schedule timers, debouncers, and async work safely on the UI thread. After installing the webforJ AI plugin, ask your assistant:
- "Refresh this dashboard every 30 seconds."
- "Add a search-as-you-type debouncer."
- "Run this CPU-heavy work in the background and update the progress bar."
Entendiendo el modelo de hilos
webforJ impone un modelo de hilos estricto donde todas las operaciones de la interfaz de usuario deben ocurrir en el hilo Environment. Esta restricción existe porque:
- Restricciones de la API webforJ: La API webforJ subyacente se vincula al hilo que creó la sesión.
- Afinidad de hilo de componentes: Los componentes de la interfaz de usuario mantienen un estado que no es seguro para los hilos.
- Despacho de eventos: Todos los eventos de la interfaz de usuario se procesan secuencialmente en un solo hilo.
Este modelo de un solo hilo previene condiciones de carrera y mantiene un estado consistente para todos los componentes de la interfaz de usuario, pero crea desafíos al integrarse con tareas de cálculo asíncronas y de larga duración.
API RunLater
La API Environment.runLater() proporciona dos métodos para programar actualizaciones de la interfaz de usuario:
// Programar una tarea sin valor de retorno
public static PendingResult<Void> runLater(Runnable task)
// Programar una tarea que devuelve un valor
public static <T> PendingResult<T> runLater(Supplier<T> supplier)
Ambos métodos devuelven un PendingResult que rastrea la finalización de la tarea y proporciona acceso al resultado o cualquier excepción que haya ocurrido.
Herencia del contexto de hilo
La herencia de contexto automática es una característica crítica de Environment.runLater(). Cuando un hilo que se ejecuta en un Environment crea hilos secundarios, esos hijos heredan automáticamente la capacidad de usar runLater().
Cómo funciona la herencia
Cualquier hilo creado desde un hilo Environment tiene automáticamente acceso a ese Environment. Esta herencia sucede automáticamente, por lo que no necesitas pasar ningún contexto ni configurar nada.
@Route
public class DataView extends Composite<Div> {
private final ExecutorService executor = Executors.newCachedThreadPool();
public DataView() {
// Este hilo tiene contexto de Environment
// Los hilos secundarios heredan el contexto automáticamente
executor.submit(() -> {
String data = fetchRemoteData();
// Puede usar runLater porque se heredó el contexto
Environment.runLater(() -> {
dataLabel.setText(data);
loadingSpinner.setVisible(false);
});
});
}
}
Hilos sin contexto
Los hilos creados fuera del contexto Environment no pueden usar runLater() y lanzarán una IllegalStateException:
// Inicializador estático - sin contexto de Environment
static {
new Thread(() -> {
Environment.runLater(() -> {}); // Lanza IllegalStateException
}).start();
}
// Hilos de temporizador del sistema - sin contexto de Environment
Timer timer = new Timer();
timer.schedule(new TimerTask() {
public void run() {
Environment.runLater(() -> {}); // Lanza IllegalStateException
}
}, 1000);
// Hilos de bibliotecas externas - sin contexto de Environment
httpClient.sendAsync(request, responseHandler)
.thenAccept(response -> {
Environment.runLater(() -> {}); // Lanza IllegalStateException
});
Comportamiento de ejecución
El comportamiento de ejecución de runLater() depende de qué hilo lo llame:
Desde el hilo de la interfaz de usuario
Cuando se llama desde el propio hilo Environment, las tareas se ejecutan sincrónicamente e inmediatamente:
button.onClick(e -> {
System.out.println("Antes: " + Thread.currentThread().getName());
PendingResult<String> result = Environment.runLater(() -> {
System.out.println("Dentro: " + Thread.currentThread().getName());
return "completado";
});
System.out.println("Después: " + result.isDone()); // true
});
Con este comportamiento sincrónico, las actualizaciones de la interfaz de usuario desde los controladores de eventos se aplican de inmediato y no incurren en sobrecarga de colas innecesaria.
Desde hilos de fondo
Cuando se llama desde un hilo de fondo, las tareas se ponen en cola para ejecución asincrónica:
@Override
public void onDidCreate() {
CompletableFuture.runAsync(() -> {
// Esto se ejecuta en el hilo ForkJoinPool
System.out.println("Fondo: " + Thread.currentThread().getName());
PendingResult<Void> result = Environment.runLater(() -> {
// Esto se ejecuta en el hilo de Environment
System.out.println("Actualización de UI: " + Thread.currentThread().getName());
statusLabel.setText("Procesamiento completo");
});
// result.isDone() sería falso aquí
// La tarea está en cola y se ejecutará de forma asincrónica
});
}
webforJ procesa las tareas enviadas desde hilos de fondo en orden FIFO estricto, preservando la secuencia de operaciones incluso cuando se envían desde múltiples hilos de forma concurrente. Con esta garantía de orden, las actualizaciones de la interfaz de usuario se aplican en el orden exacto en que fueron enviadas. Así que si el hilo A envía la tarea 1, y luego el hilo B envía la tarea 2, la tarea 1 siempre se ejecutará antes que la tarea 2 en el hilo de la interfaz de usuario. Procesar tareas en orden FIFO previene inconsistencias en la interfaz de usuario.
Cancelación de tareas
El PendingResult devuelto por Environment.runLater() soporta cancelaciones, permitiéndote evitar que las tareas en cola se ejecuten. Al cancelar tareas pendientes, puedes evitar fugas de memoria y prevenir que operaciones de larga duración actualicen la interfaz de usuario después de que ya no se necesiten.
Cancelación básica
PendingResult<Void> result = Environment.runLater(() -> {
updateUI();
});
// Cancelar si aún no se ha ejecutado
if (!result.isDone()) {
result.cancel();
}
Gestión de múltiples actualizaciones
Al realizar operaciones de larga duración con actualizaciones frecuentes de la interfaz de usuario, rastrea todos los resultados pendientes:
public class LongRunningTask {
private final List<PendingResult<?>> pendingUpdates = new ArrayList<>();
private volatile boolean isCancelled = false;
public void startTask() {
CompletableFuture.runAsync(() -> {
for (int i = 0; i <= 100; i++) {
if (isCancelled) return;
final int progress = i;
PendingResult<Void> update = Environment.runLater(() -> {
progressBar.setValue(progress);
});
// Rastrear para posible cancelación
pendingUpdates.add(update);
Thread.sleep(100);
}
});
}
public void cancelTask() {
isCancelled = true;
// Cancelar todas las actualizaciones de la interfaz de usuario pendientes
for (PendingResult<?> pending : pendingUpdates) {
if (!pending.isDone()) {
pending.cancel();
}
}
pendingUpdates.clear();
}
}
Gestión del ciclo de vida del componente
Cuando los componentes son destruidos (por ejemplo, durante la navegación), cancela todas las actualizaciones pendientes para prevenir fugas de memoria:
@Route
public class CleanupView extends Composite<Div> {
private final List<PendingResult<?>> pendingUpdates = new ArrayList<>();
@Override
protected void onDestroy() {
super.onDestroy();
// Cancelar todas las actualizaciones pendientes para prevenir fugas de memoria
for (PendingResult<?> pending : pendingUpdates) {
if (!pending.isDone()) {
pending.cancel();
}
}
pendingUpdates.clear();
}
}
Consideraciones de diseño
-
Requisito de contexto: Los hilos deben haber heredado un contexto de
Environment. Los hilos de bibliotecas externas, temporizadores del sistema y inicializadores estáticos no pueden usar esta API. -
Prevención de fugas de memoria: Siempre rastrea y cancela los objetos
PendingResulten los métodos del ciclo de vida del componente. Las lambdas en cola capturan referencias a los componentes de la interfaz de usuario, previniendo la recolección de basura si no se cancelan. -
Ejecución FIFO: Todas las tareas se ejecutan en un estricto orden FIFO sin importar su importancia. No hay un sistema de prioridades.
-
Limitaciones de cancelación: La cancelación solo previene la ejecución de tareas en cola. Las tareas que ya se están ejecutando se completarán normalmente.
Estudio de caso completo: LongTaskView
Lo siguiente es una implementación completa y lista para producción que demuestra todas las mejores prácticas para actualizaciones asincrónicas de la interfaz de usuario:
Análisis del estudio de caso
Esta implementación demuestra varios patrones críticos:
1. Gestión del grupo de hilos
private final ExecutorService executor = Executors.newSingleThreadExecutor(r -> {
Thread t = new Thread(r, "LongTaskView-Worker");
t.setDaemon(true);
return t;
});
- Utiliza un ejecutor de un solo hilo para prevenir el agotamiento de recursos.
- Crea hilos demonio que no impedirán el apagado de la JVM.
2. Seguimiento de actualizaciones pendientes
private final List<PendingResult<?>> pendingUIUpdates = new ArrayList<>();
Cada llamada a Environment.runLater() se rastrea para permitir:
- Cancelación cuando el usuario hace clic en cancelar.
- Prevención de fugas de memoria en
onDestroy(). - Limpieza adecuada durante el ciclo de vida del componente.
3. Cancelación cooperativa
private volatile boolean isCancelled = false;
El hilo de fondo verifica esta bandera en cada iteración, permitiendo:
- Respuesta inmediata a la cancelación.
- Salida limpia del bucle.
- Prevención de actualizaciones adicionales de la interfaz de usuario.
4. Gestión del ciclo de vida
@Override
protected void onDestroy() {
super.onDestroy();
cancelTask(); // Reutiliza la lógica de cancelación.
currentTask = null;
executor.shutdown();
}
Crítico para prevenir fugas de memoria mediante:
- Cancelación de todas las actualizaciones de UI pendientes.
- Interrupción de hilos en ejecución.
- Apagado del ejecutor.
5. Prueba de la receptividad de la UI
testButton.onClick(e -> {
int count = clickCount.incrementAndGet();
showToast("Clic #" + count + " - ¡La UI es receptiva!", Theme.GRAY);
});
Demuestra que el hilo de la interfaz de usuario permanece receptivo durante las operaciones de fondo.