Supersonic Subatomic Java. Así se presenta Quarkus, y no es solo marketing: arranca en milisegundos, consume poca memoria y se compila a nativo sin despeinarse. Pero hay una pregunta que todo equipo se hace en cuanto empieza un servicio con Quarkus: ¿lo escribo síncrono o asíncrono?
La respuesta corta es que Quarkus siempre es reactivo por dentro, y lo que tú eliges es hasta dónde llega esa reactividad a tu código. En este artículo te cuento los modelos que tienes, del más sencillo al más exigente, con el mismo ejemplo en cada uno, y cuál elijo yo hoy.
Los ejemplos son de Quarkus 3 con Java 21, usando Quarkus REST (lo que antes se llamaba RESTEasy Reactive) y Panache sobre PostgreSQL.
Dos tipos de hilos
Para entender todo lo demás hay que entender esto. Por debajo, Quarkus se apoya en Vert.x, que trabaja con dos tipos de hilos:
- Hilos de E/S (event loop): muy pocos, normalmente dos por núcleo. Cada uno atiende muchísimas peticiones a la vez, con una condición: no se pueden bloquear nunca. Si uno se queda esperando a la base de datos, todas las peticiones que dependen de él se quedan esperando también.
- Hilos de trabajo (worker): un grupo mucho más grande, pensado para código que sí se bloquea (consultas JDBC, llamadas HTTP síncronas, ficheros…). Cada petición ocupa un hilo mientras dura.
Con Quarkus REST, la firma del método decide en qué hilo se ejecuta:
Puedes forzar el comportamiento con @Blocking y @NonBlocking, pero normalmente no hace falta: Quarkus acierta solo.
1. Síncrono: el de toda la vida
El ejemplo es actualizar una tarea: si existe, cambiamos sus campos y devolvemos un 204; si no, un 404. Con la extensión quarkus-hibernate-orm-panache (bloqueante):
@Entity
public class Tarea extends PanacheEntity { // io.quarkus.hibernate.orm.panache
public String nombre;
public Integer duracion;
}
@Path("/tareas")
@Consumes(MediaType.APPLICATION_JSON)
public class TareaResource {
@PUT
@Path("{id}")
@Transactional
public Response actualizar(@PathParam("id") Long id, Tarea tarea) {
Tarea existente = Tarea.findById(id);
if (existente == null) {
return Response.status(Response.Status.NOT_FOUND).build();
}
existente.nombre = tarea.nombre;
existente.duracion = tarea.duracion;
return Response.noContent().build();
}
}
Se lee de arriba abajo, se depura con puntos de ruptura normales y las trazas de error dicen exactamente dónde ha fallado. Como devuelve un tipo normal (Response), Quarkus lo ejecuta en un hilo de trabajo y puede bloquearse esperando a la base de datos sin molestar a nadie.
Fíjate en un detalle: aunque tu código sea síncrono, la capa HTTP de Quarkus sigue siendo reactiva. La petición entra por el event loop y solo tu método pasa a un hilo de trabajo. En mis notas lo llamaba «half async»: es lo que tienes por defecto, y es la razón de que Quarkus rinda bien incluso con código bloqueante.
El límite es el número de hilos de trabajo. Por defecto, el grupo crece hasta el mayor de 200 u 8 por núcleo. Si cada petición pasa medio segundo esperando a otro servicio, con 200 hilos no atiendes más de 400 peticiones por segundo, por mucha CPU libre que tengas.
2. Asíncrono del todo: Mutiny y Hibernate Reactive
El modelo «full async» lleva la reactividad hasta la base de datos. Cambias a quarkus-hibernate-reactive-panache y al cliente reactivo de PostgreSQL, y tu método deja de devolver un resultado para devolver la promesa de un resultado, un Uni de Mutiny:
@Entity
public class Tarea extends PanacheEntity { // io.quarkus.hibernate.reactive.panache
public String nombre;
public Integer duracion;
}
@PUT
@Path("{id}")
@WithTransaction
public Uni<Response> actualizar(@PathParam("id") Long id, Tarea tarea) {
return Tarea.<Tarea>findById(id)
.map(existente -> {
if (existente == null) {
return Response.status(Response.Status.NOT_FOUND).build();
}
existente.nombre = tarea.nombre;
existente.duracion = tarea.duracion;
return Response.noContent().build();
});
}
Aquí ningún hilo espera nunca: el event loop lanza la consulta, se va a atender otras peticiones y, cuando PostgreSQL responde, retoma el map. Con un puñado de hilos atiendes miles de peticiones concurrentes y con muy poca memoria.
Si vienes de versiones anteriores, verás código con @ReactiveTransactional o con Panache.withTransaction(...) (como el de la imagen de este artículo). En Quarkus 3 lo habitual es la anotación @WithTransaction, que deja el código mucho más limpio.
El precio: el código se escribe como una cadena de transformaciones, las trazas de error son menos claras, depurar cuesta más y todo lo que toques tiene que ser reactivo. Y eso nos lleva al error más común.
3. El error clásico: bloquear el event loop
Mezclar los dos mundos sin cuidado es la forma más rápida de tener un servicio lento con un modelo «rápido». Esto, por ejemplo, está mal:
@GET
public Uni<String> informe() {
String datos = clienteLento.consultar(); // llamada bloqueante... en el hilo de E/S
return Uni.createFrom().item(datos);
}
Como devuelve un Uni, se ejecuta en el event loop, y la llamada bloqueante lo congela. Vert.x te avisará en el registro con un Thread vert.x-eventloop-thread-0 has been blocked for ..., y en algunos casos (como usar Hibernate ORM bloqueante) Quarkus directamente se negará con una excepción. Tienes dos salidas:
// a) Decirle a Quarkus que este método bloquea: se ejecutará en un hilo de trabajo
@GET
@Blocking
public Uni<String> informe() { ... }
// b) Sacar solo la parte bloqueante a un hilo de trabajo y seguir siendo reactivo
@GET
public Uni<String> informe() {
return Uni.createFrom().item(() -> clienteLento.consultar())
.runSubscriptionOn(Infrastructure.getDefaultWorkerPool());
}
La regla es sencilla: si devuelves Uni o Multi, no bloquees nunca.
4. Hilos virtuales: lo mejor de los dos mundos (casi)
Desde Java 21 hay una tercera vía, y es la que más ha cambiado mi recomendación. Los hilos virtuales son hilos que gestiona la JVM, no el sistema operativo: cuestan muy poco y cuando uno se bloquea esperando E/S, libera el hilo real para otro. Puedes tener cientos de miles.
En Quarkus se activan con una anotación sobre el mismo código síncrono del principio:
@PUT
@Path("{id}")
@Transactional
@RunOnVirtualThread
public Response actualizar(@PathParam("id") Long id, Tarea tarea) {
// exactamente el mismo código que la versión síncrona
}
Código sencillo de leer y depurar, y una capacidad de concurrencia cercana a la del modelo reactivo. Pero hay que conocer sus trampas:
- El cuello de botella se muda a la base de datos. Los hilos virtuales no crean conexiones: si el pool tiene 20, solo 20 peticiones consultan a la vez y el resto espera su turno. Dimensiona el pool (y lo que aguante tu PostgreSQL) en consecuencia.
- El anclaje (pinning). En Java 21, un hilo virtual que se bloquea dentro de un bloque
synchronizedse queda «anclado» al hilo real y pierde la ventaja. Java 24 lo resolvió, pero si estás en 21, vigila las bibliotecas que uses. - No los metas en un pool ni guardes cosas caras en
ThreadLocal: están pensados para crearse y tirarse uno por tarea.
Comparativa
| Síncrono | Asíncrono (Mutiny) | Hilos virtuales | |
|---|---|---|---|
| Hilo donde corre tu código | De trabajo | De E/S | Virtual |
| Persistencia | Hibernate ORM | Hibernate Reactive | Hibernate ORM |
| Facilidad de escritura y depuración | Alta | Baja | Alta |
| Peticiones concurrentes | Limitadas por los hilos de trabajo | Muy altas | Muy altas (limitadas por el pool de conexiones) |
| Memoria por petición | Alta (un hilo del sistema) | Mínima | Baja |
| Riesgo típico | Agotar los hilos de trabajo | Bloquear el event loop | Anclaje y pool de conexiones |
¿Cuál elijo?
Mi criterio, a día de hoy:
- Empieza síncrono. Para la gran mayoría de servicios (un CRUD, una API interna, un backend de gestión), el modelo bloqueante de Quarkus rinde de sobra y es el más fácil de mantener por cualquier persona del equipo.
- Si te quedas corto de concurrencia porque pasas mucho tiempo esperando a otros servicios o a la base de datos, añade
@RunOnVirtualThreaddonde haga falta antes de reescribir nada. - Ve a reactivo del todo cuando de verdad lo aproveches: streaming (
Multi, SSE, WebSockets), mensajería con Kafka, composición de muchas llamadas en paralelo, o servicios que tienen que exprimir al máximo muy poca memoria. Y solo si el equipo conoce Mutiny.
Lo que no recomiendo es elegir el modelo reactivo «porque es más rápido»: con un equipo que no lo domina, acabas con un event loop bloqueado y un servicio más lento y más difícil de depurar que su versión síncrona.
Conclusión
Con Quarkus no hay que elegir entre sencillez y rendimiento de forma tan drástica como antes: la capa HTTP ya es reactiva aunque tú escribas código síncrono, y los hilos virtuales te dan concurrencia alta sin cambiar de paradigma. El modelo reactivo completo sigue siendo la mejor herramienta para streaming y mensajería, pero ya no es la única forma de escalar.




