Las 40 preguntas y respuestas principales de la entrevista sobre subprocesos múltiples de Java - Edición 2026

La preparación para una entrevista sobre subprocesos múltiples en Java exige una comprensión profunda de los conceptos de concurrencia y experiencia práctica. A continuación encontrará 40 preguntas cuidadosamente elaboradas y respuestas de expertos que cubren todo, desde definiciones básicas hasta temas avanzados como hilos virtuales y simultaneidad estructurada.

👉 Descarga gratuita de PDF:Preguntas y respuestas de la entrevista sobre subprocesos múltiples de Java

1) ¿Qué es Multithreading en Java y por qué se utiliza?

El multiproceso permite que una aplicación Java ejecute varios subprocesos simultáneamente, maximizando la utilización de la CPU y mejorando la capacidad de respuesta. Es especialmente valioso para tareas vinculadas a E/S, cálculos a gran escala y actualizaciones de GUI donde un subproceso puede bloquearse mientras otro continúa procesando.

Beneficios

• Mayor utilización de la CPU
• Latencia reducida para operaciones independientes
• Respuesta mejorada de la interfaz de usuario

Ejemplo :Un servidor web puede manejar docenas de solicitudes de clientes simultáneamente asignando cada solicitud a un hilo separado, evitando así el bloqueo de las operaciones de E/S.

2) Explicar el ciclo de vida de un hilo en Java.

Los subprocesos de Java avanzan a través de los siguientes estados:

Estado	Descripción
Nuevo	Subproceso creado pero aún no iniciado.
Ejecutable	El hilo está listo para ejecutarse o actualmente en ejecución.
Bloqueado	El hilo espera un bloqueo del monitor.
Esperando	El hilo espera indefinidamente la señal de otro hilo.
Espera programada	El hilo espera durante un tiempo específico.
Terminado	El hilo ha finalizado su ejecución.

Cuando t.start() se invoca, el hilo se mueve desde Nuevo a Ejecutable .

3) ¿Cuál es la diferencia entre un proceso y un hilo?

Criterios	Proceso	Hilo
Memoria	Espacio de direcciones propio	Comparte memoria de proceso
Comunicación	Requiere IPC	Comparte memoria directamente
Costo de creación	Caro	Ligero
Impacto del fallo	Aislado	Puede afectar a los hermanos

Por ejemplo, un proceso de navegador puede contener múltiples subprocesos para renderizado, creación de redes e interacción del usuario.

4) ¿Cómo funciona la sincronización en Java?

La sincronización garantiza que solo un subproceso acceda a un recurso compartido a la vez, lo que evita condiciones de carrera y corrupción de datos. El synchronized La palabra clave bloquea un método completo o un bloque específico.

1. Método sincronizado – bloquea el monitor del método.
2. Bloque sincronizado – bloquea un objeto elegido.

synchronized void increment() {
    count++;
}

5) ¿Cuáles son las diferentes formas de crear un hilo en Java?

1. Extendiendo Thread

   class MyThread extends Thread {
       public void run() { System.out.println("Thread running"); }
   }
   new MyThread().start();

2. Implementación de Runnable

   class MyRunnable implements Runnable {
       public void run() { System.out.println("Runnable running"); }
   }
   new Thread(new MyRunnable()).start();

3. Invocable y futuro (moderno) – devuelve un valor y puede generar excepciones marcadas.

   Callable task = () -> 42;
   Future result = executor.submit(task);
   System.out.println(result.get());

6) ¿Cuál es la diferencia entre start() y run() ?

Aspecto	start()	run()
Creación de hilo	Crea un nuevo hilo del sistema operativo	Se ejecuta en el hilo actual
Invocación	Programa hilo en JVM	Llamada a método simple
Simultaneidad	Ejecución asincrónica	Ejecución secuencial

Llamando a t.start() lanza un nuevo hilo; t.run() se comporta como cualquier otro método.

7) Explique el concepto de seguridad de subprocesos y cómo lograrlo.

La seguridad de subprocesos garantiza que el acceso simultáneo a datos compartidos no dañe el estado. Se puede lograr a través de:

• synchronized bloques o métodos
• volatile variables
• Bloqueos explícitos (por ejemplo, ReentrantLock , ReadWriteLock )
• Colecciones seguras para subprocesos (ConcurrentHashMap , CopyOnWriteArrayList )
• Clases atómicas (AtomicInteger , AtomicBoolean )

AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();

8) ¿Cuál es la diferencia entre wait() , sleep() y yield() ?

Método	Clase	Apertura de bloqueo	Propósito	Duración
wait()	Objeto	Sí	Esperar notificación	Hasta que se notifique
sleep()	Subproceso	No	Pausar la ejecución	Tiempo fijo
yield()	Subproceso	No	Sugerir cambio de programador	Impredecible

Utilice wait() para comunicación entre hilos; utilizar sleep() para pausar un hilo.

9) ¿Cómo mejora Executor Framework la gestión de subprocesos?

El marco desacopla el envío de tareas de la creación de subprocesos, lo que permite una agrupación de subprocesos y una reutilización de recursos eficientes. Es parte de java.util.concurrent y ofertas:

• Reutilización de hilos para reducir los gastos generales
• Tipos de grupos flexibles (fijo, en caché, único, programado, robo de trabajo)
• Mecanismos de apagado elegantes

ExecutorService executor = Executors.newFixedThreadPool(5);
executor.submit(() -> System.out.println("Task executed"));
executor.shutdown();

10) ¿Cuáles son los diferentes tipos de grupos de subprocesos disponibles en Java?

Tipo de grupo	Método de fábrica	Descripción
FixedThreadPool	nuevoFixedThreadPool(n)	Número fijo de hilos
CachedThreadPool	newCachedThreadPool()	Crea subprocesos según sea necesario, reutilizando los inactivos
Ejecutor de hilo único	newSingleThreadExecutor()	Subproceso de trabajo único para ejecución secuencial
ScheduledThreadPool	nuevoScheduledThreadPool(n)	Admite tareas retrasadas o periódicas
Grupo de robo de trabajo	newWorkStealingPool()	Utiliza los procesadores disponibles dinámicamente

11) ¿Qué es un punto muerto en Java y cómo se puede prevenir?

Un punto muerto ocurre cuando dos o más subprocesos esperan indefinidamente entre sí para liberar los bloqueos. Por lo general, surge de un orden de bloqueo inconsistente.

synchronized (A) {
    synchronized (B) { /*...*/ }
}

synchronized (B) {
    synchronized (A) { /*...*/ }
}

Estrategias de prevención:

1. Adquirir candados en un orden global consistente.
2. Usar tryLock() con un tiempo de espera.
3. Evite los bloqueos anidados cuando sea posible.
4. Prefiera las utilidades de simultaneidad de alto nivel a los bloqueos manuales.

12) Diferencia entre synchronized y ReentrantLock .

Característica	synchronized	Bloqueo reentrante
Adquisición	Implícito	Explícito vía lock()
Desbloqueo	Salida automática del método	Manual vía unlock()
Intento/Tiempo de espera	No disponible	Soporta tryLock() y tiempo de espera
Equidad	No configurable	Admite pedidos justos
Variables de condición	No compatible	Admite múltiples Condition objetos

ReentrantLock lock = new ReentrantLock();
if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try { /* critical section */ } finally { lock.unlock(); }
}

13) Diferencia entre volatile y synchronized .

Aspecto	volátil	sincronizado
Propósito	Visibilidad	Atomicidad + visibilidad
Atomicidad	Sin garantía	Garantizado
Bloqueo	No	Sí
Caso de uso	Banderas simples	Operaciones compuestas

volatile boolean running = true;

synchronized void increment() { count++; }

14) Explica ThreadLocal en Java.

ThreadLocal proporciona datos específicos de subprocesos, lo que elimina la necesidad de un estado mutable compartido. Cada hilo accede a su propia copia aislada.

ThreadLocal counter = ThreadLocal.withInitial(() -> 0);
counter.set(counter.get() + 1);

• Evita la corrupción de datos
• Útil para el contexto por subproceso (por ejemplo, ID de sesión)
• Debe llamar al remove() en grupos de subprocesos para evitar pérdidas de memoria

15) ¿Qué son las clases atómicas en Java y por qué se usan?

Clases atómicas (por ejemplo, AtomicInteger , AtomicBoolean , AtomicReference ) realiza operaciones sin bloqueos y seguras para subprocesos mediante CAS (Compare-And-Swap). Ofrecen un mayor rendimiento para actualizaciones simples en comparación con los bloques sincronizados.

AtomicInteger counter = new AtomicInteger();
counter.incrementAndGet();

16) ¿Qué es un semáforo y en qué se diferencia de un candado?

Aspecto	Semáforo	Bloquear
Propósito	Limitar el acceso simultáneo	Exclusión mutua
Permisos	Múltiples	Único
Bloqueo	Adquiere permiso	Adquiere propiedad
Caso de uso	Agrupación de conexiones	Protección de secciones críticas

Semaphore sem = new Semaphore(3);
sem.acquire();
// use resource
sem.release();

17) Explique el marco de bifurcación/join.

Introducido en Java 7, permite la ejecución paralela de tareas divisibles de forma recursiva mediante un algoritmo de robo de trabajo. Los subprocesos inactivos roban trabajo a los ocupados, maximizando la utilización de la CPU.

class SumTask extends RecursiveTask {
    protected Integer compute() {
        if (end - start <= threshold) return computeDirectly();
        int mid = (start + end) / 2;
        SumTask left = new SumTask(start, mid);
        SumTask right = new SumTask(mid, end);
        left.fork();
        return right.compute() + left.join();
    }
}

18) ¿Cómo mejora CompletableFuture la programación asincrónica?

CompletableFuture permite operaciones asincrónicas componibles y sin bloqueo, eliminando el infierno de devoluciones de llamadas y admitiendo encadenamiento, manejo de excepciones y composición paralela.

CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(str -> str + " World")
    .thenAccept(System.out::println);

19) ¿Qué es un hilo de demonio?

Los subprocesos de Daemon se ejecutan en segundo plano y brindan servicios como recolección de basura o tareas de temporizador. La JVM finaliza todos los subprocesos del demonio automáticamente cuando no quedan subprocesos de usuario.

Thread daemon = new Thread(() -> System.out.println("Daemon running"));
daemon.setDaemon(true);
daemon.start();

20) Mejores prácticas para subprocesos múltiples en Java.

1. Prefiere utilidades de simultaneidad de alto nivel (ExecutorService, BlockingQueue).
2. Evitar el estado mutable compartido; favorecer la inmutabilidad.
3. Utilice colecciones simultáneas en contenedores sincronizados.
4. Manejar las interrupciones correctamente y restaurar el indicador de interrupción.
5. Apague los ejecutores correctamente con shutdown() o shutdownNow() .
6. Minimice el alcance de la sincronización para reducir la contención.
7. Perfil antes de optimizar; herramientas como JFR y async-profiler ayudan a identificar puntos de acceso.

21) ¿Qué es el modelo de memoria Java (JMM) y por qué es importante?

El JMM define cómo interactúan los subprocesos a través de la memoria, garantizando visibilidad, ordenamiento y atomicidad. Establece la relación sucede antes, que es fundamental para escribir código concurrente correcto.

• Visibilidad:los cambios realizados por un hilo deben ser vistos por otros.
• Ordenado:las acciones se ordenan para preservar la coherencia.
• Atomicidad:ciertas operaciones son indivisibles.

22) Diferencia entre ConcurrentHashMap y sincronizadoMap.

Característica	ConcurrentHashMap	Mapa sincronizado
Bloqueo de granularidad	Nivel de segmento (parcial)	Mapa completo
Rendimiento en disputa	Alto	Bajo
Claves/valores nulos	No permitido	Permitido
Consistencia del iterador	Débilmente consistente	Falla rápida
Lecturas simultáneas	Permitido	Bloqueado

23) Detectar y depurar puntos muertos.

1. Volcados de subprocesos a través de jstack <pid> revelar puntos muertos.
2. VisualVM o JConsole proporcionan supervisión de subprocesos en tiempo real.
3. Detección programática con ThreadMXBean.findDeadlockedThreads() .

24) Secuencias paralelas frente a subprocesos explícitos.

Las transmisiones paralelas utilizan internamente el marco Fork/Join, que ofrece una API de alto nivel para el procesamiento de datos. Los subprocesos explícitos requieren gestión manual pero proporcionan un control detallado.

Aspecto	Transmisiones paralelas	Hilos
Abstracción	API de alto nivel	Control de bajo nivel
Gestión	Automático a través de ForkJoinPool	Grupo de subprocesos manual
Sintonización	Utiliza un fondo común	Tamaño de grupo personalizado
Manejo de errores	Limitado	Control total

25) CountDownLatch, CyclicBarrier y Phaser.

Característica	CountDownLatch	Barrera Cíclica	Fáser
Restablecer	No	Sí	Sí
Fiestas	Fijo	Fijo	Dinámico
Caso de uso	Esperar a que finalicen las tareas	Temas a cumplir	Coordinación dinámica

CountDownLatch latch = new CountDownLatch(3);
for (...) new Thread(() -> { /* work */ latch.countDown(); }).start();
latch.await();

26) Diferencia entre invocable y ejecutable.

Aspecto	Ejecutable	Invocable
Valor de retorno	No	Sí
Excepciones marcadas	No	Sí
Paquete	java.lang	java.util.concurrent

Callable task = () -> 42;
Future result = executor.submit(task);
System.out.println(result.get());

27) BlockingQueue para productor-consumidor.

BlockingQueue ofrece operaciones de bloqueo seguras para subprocesos que simplifican el patrón productor-consumidor.

BlockingQueue queue = new ArrayBlockingQueue<>(10);
new Thread(() -> queue.put(1)).start(); // Producer
new Thread(() -> System.out.println(queue.take())).start(); // Consumer

• Elimina el manual wait() /notify() .
• Admite implementaciones limitadas e ilimitadas.

28) Inanición de subprocesos y bloqueo en vivo.

La inanición se produce cuando los subprocesos de baja prioridad nunca reciben tiempo de CPU. Livelock ocurre cuando los subprocesos cambian continuamente de estado pero no progresan. La mitigación incluye bloqueos justos, evitar esperas ajetreadas y una programación adecuada.

29) Mejora del rendimiento de aplicaciones multiproceso.

1. Usar grupos de subprocesos.
2. Reducir el alcance de la sincronización.
3. Aprovechar las estructuras de datos concurrentes.
4. Prefiere objetos inmutables.
5. Evite el intercambio falso.
6. Ajuste el número de subprocesos a los núcleos de la CPU.
7. Utilice E/S asíncronas para bloquear operaciones.

30) Escenario de subprocesos múltiples del mundo real.

En una pasarela de pago, el procesamiento de transacciones simultáneas se optimizó mediante:

1. ExecutorService para subprocesos de trabajo.
2. ConcurrentHashMap para el estado de la transacción.
3. ReentrantLock para bloqueo a nivel de cuenta.
4. CountDownLatch para sincronización por lotes.
5. CompletableFuture para respuestas asíncronas.

Resultado:35 % de ganancia de rendimiento y 40 % de reducción de latencia.

31) Hilos virtuales en Java.

Los subprocesos virtuales, introducidos en Java 21, son subprocesos livianos administrados por JVM, que permiten millones de tareas simultáneas con una sobrecarga mínima.

Característica	Hilos de plataforma	Hilos virtuales
Administrado por	SO	JVM
Coste de creación	Alto	Muy bajo
Nivel de simultaneidad	Miles	Millones
Programación	Nivel de sistema operativo	Cooperativa JVM
Caso de uso	Tareas vinculadas a la CPU	Tareas vinculadas a E/S/de alta concurrencia

Thread.startVirtualThread(() -> System.out.println("Virtual thread running"));

32) Simultaneidad estructurada.

La simultaneidad estructurada, vista previa en Java 21, trata varias tareas simultáneas como una sola unidad, lo que garantiza que se inicien, gestionen y finalicen juntas. Elimina subprocesos huérfanos y simplifica la propagación de errores.

try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
    Future user = scope.fork(() -> findUser());
    Future order = scope.fork(() -> fetchOrderCount());
    scope.join();
    scope.throwIfFailed();
    System.out.println(user.resultNow() + " has " + order.resultNow() + " orders.");
}

33) Flujos reactivos en Java.

Reactive Streams proporciona un modelo sin bloqueo y consciente de la contrapresión para manejar flujos de datos, formando la base para marcos como Project Reactor, RxJava y Spring WebFlux.

• Publisher – produce datos.
• Subscriber – consume datos.
• Subscription – controla el flujo.
• Processor – tanto el editor como el suscriptor.

Flow.Publisher publisher = subscriber -> subscriber.onNext(42);

34) Manejo adecuado de la interrupción del hilo.

Siempre revisa Thread.interrupted() en bucles, limpiar recursos y preservar el estado de interrupción después de detectar InterruptedException .

while (!Thread.currentThread().isInterrupted()) {
    try { Thread.sleep(1000); }
    catch (InterruptedException e) {
        Thread.currentThread().interrupt(); // restore flag
        break;
    }
}

35) Paralelismo versus concurrencia.

La simultaneidad gestiona múltiples tareas intercalando la ejecución, mientras que el paralelismo ejecuta tareas simultáneamente en múltiples núcleos de CPU.

Concepto	Definición	Ejemplo
Simultaneidad	Entrelazando tareas	Manejando 1000 solicitudes de clientes simultáneamente
Paralelismo	Ejecución simultánea	Ejecutar cálculos en los núcleos de la CPU

36) Herramientas y técnicas de creación de perfiles de subprocesos.

Herramienta	Propósito
jstack	Captura de volcado de subprocesos
jconsole/VisualVM	Monitoreo en tiempo real
Grabador de vuelo Java (JFR)	Perfiles con bajos gastos generales
Control de misión (JMC)	Visualización de grabaciones JFR
perfilador asíncrono	CPU y perfiles de asignación
ThreadMXBean	Inspección programática

ThreadMXBean bean = ManagementFactory.getThreadMXBean();
System.out.println(bean.getThreadCount());

37) Cuellos de botella comunes en el rendimiento.

1. Contención de bloqueo excesiva.
2. Falso intercambio de variables.
3. Generalidades del cambio de contexto.
4. Sincronización incorrecta.
5. Uso excesivo de variables volátiles.

Las optimizaciones incluyen bloqueo detallado, estructuras sin bloqueo, minimización de la creación de subprocesos y uso de almacenamiento local de subprocesos.

38) Algoritmos sin bloqueos, sin esperas y sin obstrucciones.

Tipo	Definición	Garantía
Sin bloqueo	Al menos un hilo progresa.	Progreso en todo el sistema.
Sin espera	Cada hilo avanza en pasos acotados.	La garantía más sólida.
Sin obstáculos	Progreso sin conflictos.	Garantía más débil.

Las operaciones AtomicInteger no tienen bloqueos; las colas de bloqueo utilizan candados.

39) Componentes internos de ForkJoinPool.

Cada trabajador mantiene su propio deque; Los trabajadores inactivos roban tareas de otros, lo que reduce la contención y mejora el rendimiento.

ForkJoinPool pool = new ForkJoinPool();
pool.submit(() -> IntStream.range(0, 100).parallel().forEach(System.out::println));

40) Diseñar un sistema altamente concurrente para millones de solicitudes.

1. Subprocesos virtuales para un manejo ligero de solicitudes.
2. Secuencias reactivas para E/S asíncronas.
3. Simultaneidad estructurada para ciclos de vida de tareas predecibles.
4. Cachés de alto rendimiento (ConcurrentHashMap, Caffeine).
5. Colas seguras para subprocesos (Disruptor, BlockingQueue).
6. Monitoreo con JFR y JMC.
7. CompletableFuture para flujos de trabajo asíncronos.

Resultado:Logre millones de conexiones simultáneas con un bloqueo mínimo y un uso óptimo de los recursos.

🔍 Principales preguntas de la entrevista sobre subprocesos múltiples de Java con escenarios del mundo real y respuestas estratégicas

A continuación se presentan diez preguntas realistas, lo que esperan los entrevistadores y ejemplos de respuestas pulidas.

1) ¿Diferencia entre un proceso y un hilo en Java?

El candidato debe explicar los fundamentos del sistema operativo y JVM, el uso de la memoria y el flujo de ejecución. Por ejemplo, un proceso de navegador contiene múltiples subprocesos para renderizado, creación de redes y entrada del usuario.

2) Objeto del synchronized ¿palabra clave?

Explica el control de concurrencia, los bloqueos intrínsecos y la seguridad de subprocesos. Garantiza que solo un hilo acceda a una sección crítica a la vez.

3) ¿Se enfrentó y resolvió un problema desafiante de subprocesos múltiples?

Describe un escenario de interbloqueo, cómo lo identificaste mediante volcados de subprocesos y cómo lo resolviste aplicando un orden de bloqueo consistente.

4) ¿Modelo de memoria Java y visibilidad?

Describir las relaciones que suceden antes, volatile y construcciones de sincronización que garantizan visibilidad y ordenamiento.

5) Diferencia entre wait() , notify() y notifyAll() ?

Explicar la comunicación entre subprocesos y supervisar la mecánica.

6) ¿Optimizar una aplicación multiproceso?

Identifique la contención de bloqueo, reemplace synchronized con ConcurrentHashMap y mostrar ganancias de rendimiento mensurables.

7) ¿Actualizar de forma segura una estructura de datos compartida?

Utilice colecciones seguras para subprocesos o bloqueo explícito con ReentrantLock para un control granular.

8) Papel de ExecutorService ?

Gestiona un grupo de subprocesos de trabajo, reduce los gastos generales y simplifica la gestión del ciclo de vida.

9) ¿Solucionar problemas de una condición de carrera?

Reproduzca bajo carga, mejore el registro y corrija agregando la sincronización adecuada.

10) ¿Diseñar una solución multiproceso con diferentes prioridades?

Utilice una cola prioritaria con ThreadPoolExecutor y comparador personalizado para tareas de mayor prioridad.