El multiproceso y la sincronización se consideran capítulos típicos de la programación Java. En las empresas de desarrollo de juegos, la mayoría de las veces se hacen preguntas de entrevista relacionadas con subprocesos múltiples. A continuación se proporciona una lista de preguntas frecuentes de entrevistas sobre concurrencia y subprocesos múltiples de Java.

Preguntas de la entrevista sobre subprocesos múltiples

1) ¿Qué es el subproceso múltiple?

Multithreading es un proceso de ejecución de múltiples subprocesos simultáneamente. El multiproceso se utiliza para obtener la multitarea. Consume menos memoria y ofrece un rendimiento rápido y eficiente. Sus principales ventajas son:

• Los hilos comparten el mismo espacio de direcciones.
• El hilo es ligero.
• El coste de comunicación entre los procesos es bajo.

2) ¿Cuál es el hilo?

Un hilo es un subproceso ligero. Es una ruta de ejecución separada porque cada subproceso se ejecuta en un marco de pila diferente. Un proceso puede contener varios subprocesos. Los subprocesos comparten los recursos del proceso, pero aún así se ejecutan de forma independiente.

3) ¿Diferenciar entre proceso e hilo?

Existen las siguientes diferencias entre el proceso y el hilo.

• Un Programa en ejecución se llama proceso mientras que; Un hilo es un subconjunto del proceso.
• Los procesos son independientes, mientras que los subprocesos son el subconjunto del proceso.
• Los procesos tienen diferentes espacios de direcciones en la memoria, mientras que los subprocesos contienen un espacio de direcciones compartido.
• El cambio de contexto es más rápido entre subprocesos en comparación con los procesos.
• La comunicación entre procesos es más lenta y costosa que la comunicación entre subprocesos.
• Cualquier cambio en el proceso principal no afecta al proceso secundario, mientras que los cambios en el hilo principal pueden afectar al hilo secundario.

4) ¿Qué entiendes por comunicación entre hilos?

• El proceso de comunicación entre subprocesos sincronizados se denomina comunicación entre subprocesos.
• La comunicación entre subprocesos se utiliza para evitar el sondeo de subprocesos en Java.
• El subproceso se detiene en su sección crítica y se permite que otro subproceso ingrese (o se bloquee) en la misma sección crítica para ejecutarse.
• Se puede obtener mediante los métodos wait(), notify() y notifyAll().

5) ¿Cuál es el propósito del método wait() en Java?

El método wait() lo proporciona la clase Object en Java. Este método se utiliza para la comunicación entre subprocesos en Java. java.lang.Object.wait() se utiliza para pausar el hilo actual y esperar hasta que otro hilo no llame al método notify() o notifyAll(). Su sintaxis se proporciona a continuación.

espera nula final pública()

6) ¿Por qué se debe llamar al método wait() desde el bloque sincronizado?

Debemos llamar al método de espera, de lo contrario arrojará java.lang.IllegalMonitorStateException excepción. Además, necesitamos el método wait() para la comunicación entre subprocesos con notify() y notifyAll(). Por lo tanto debe estar presente en el bloque sincronizado para la adecuada y correcta comunicación.

7) ¿Cuáles son las ventajas del subproceso múltiple?

La programación multiproceso tiene las siguientes ventajas:

• El subproceso múltiple permite que una aplicación/programa esté siempre reactivo a la entrada, incluso si ya se está ejecutando con algunas tareas en segundo plano.
• El multiproceso permite una ejecución más rápida de las tareas, ya que los subprocesos se ejecutan de forma independiente.
• Los subprocesos múltiples proporcionan una mejor utilización de la memoria caché ya que los subprocesos comparten los recursos de memoria comunes.
• El subproceso múltiple reduce la cantidad de servidores requeridos, ya que un servidor puede ejecutar múltiples subprocesos a la vez.

8) ¿Cuáles son los estados en el ciclo de vida de un Thread?

Un hilo puede tener uno de los siguientes estados durante su vida:

Nuevo:En este estado, se crea un objeto de clase Thread utilizando un nuevo operador, pero el hilo no está activo. El hilo no comienza hasta que llamamos al método start().Ejecutable:En este estado, el hilo está listo para ejecutarse después de llamar al método start(). Sin embargo, el programador de subprocesos aún no ha seleccionado el hilo.Correr:En este estado, el programador de subprocesos selecciona el subproceso del estado listo y el subproceso se está ejecutando.Esperando/Bloqueado:En este estado, un subproceso no se está ejecutando pero sigue vivo o está esperando a que finalice el otro subproceso.Muerto/Terminado:Un subproceso está terminado o inactivo cuando sale el método run().

9) ¿Cuál es la diferencia entre programación preventiva y división de tiempo?

En la programación preventiva, la tarea de mayor prioridad se ejecuta hasta que entra en estado de espera o inactivo o hasta que surge una tarea de mayor prioridad. En la división de tiempo, una tarea se ejecuta durante un período de tiempo predefinido y luego vuelve a ingresar al grupo de tareas listas. Luego, el programador determina qué tarea debe ejecutarse a continuación, según la prioridad y otros factores.

10) ¿Qué es el cambio de contexto?

En el cambio de contexto, el estado del proceso (o subproceso) se almacena para que pueda restaurarse y reanudarse la ejecución desde el mismo punto más adelante. El cambio de contexto permite que múltiples procesos compartan la misma CPU.

11) ¿Diferenciar entre la clase Thread y la interfaz Runnable para crear un Thread?

El hilo se puede crear de dos formas.

• Extendiendo la clase Thread
• Implementando la interfaz Runnable

Sin embargo, las principales diferencias entre ambas formas se detallan a continuación:

• Al extender la clase Thread, no podemos extender ninguna otra clase, ya que Java no permite herencias múltiples al implementar la interfaz Runnable; También podemos ampliar otra clase base (si es necesario).
• Al extender la clase Thread, cada hilo crea el objeto único y se asocia con él mientras implementa la interfaz Runnable; varios hilos comparten el mismo objeto
• La clase Thread proporciona varios métodos incorporados como getPriority(), isAlive y muchos más, mientras que la interfaz Runnable proporciona un método único, es decir, run().

12) ¿Qué significa el método join()?

El método join() espera a que muera un hilo. En otras palabras, hace que los subprocesos que se están ejecutando actualmente dejen de ejecutarse hasta que el subproceso al que se une complete su tarea. El método Join se sobrecarga en la clase Thread de las siguientes maneras.

• unión nula pública () lanza InterruptedException
• unión nula pública (milisegundos largos) lanza InterruptedException

13) Describe el propósito y el funcionamiento del método sleep().

El método sleep() en Java se utiliza para bloquear un hilo durante un tiempo determinado, lo que significa que pausa la ejecución de un hilo durante un tiempo específico. Hay dos métodos para hacerlo.

Sintaxis:

novios y dfs

• El sueño vacío estático público (milisegundos largos) lanza una excepción interrumpida
• El sueño vacío estático público (milisegundos largos, int nanos) arroja una excepción interrumpida.

Funcionamiento del método sleep()

Cuando llamamos al método sleep(), detiene la ejecución del hilo actual durante el tiempo determinado y da prioridad a otro hilo (si está disponible). Además, cuando se completa el tiempo de espera, el subproceso anterior nuevamente cambia su estado de espera a ejecutable y pasa al estado de ejecución, y todo el proceso funciona así hasta que la ejecución no se completa.

14) ¿Cuál es la diferencia entre el método esperar() y dormir()?

15) ¿Es posible iniciar un hilo dos veces?

No, no podemos reiniciar el hilo, ya que una vez que un hilo se inicia y ejecuta, pasa al estado Muerto. Por lo tanto, si intentamos iniciar un hilo dos veces, generará una excepción de tiempo de ejecución 'java.lang.IllegalThreadStateException'. Considere el siguiente ejemplo.

 public class Multithread1 extends Thread { public void run() { try { System.out.println('thread is executing now........'); } catch(Exception e) { } } public static void main (String[] args) { Multithread1 m1= new Multithread1(); m1.start(); m1.start(); } } 

Producción

 thread is executing now........ Exception in thread 'main' java.lang.IllegalThreadStateException at java.lang.Thread.start(Thread.java:708) at Multithread1.main(Multithread1.java:13) 

16) ¿Podemos llamar al método run() en lugar de start()?

Sí, llamar al método run() directamente es válido, pero no funcionará como un hilo, sino que funcionará como un objeto normal. No habrá cambio de contexto entre los hilos. Cuando llamamos al método start(), llama internamente al método run(), que crea una nueva pila para un hilo, mientras que llamar directamente a run() no creará una nueva pila.

17) ¿Qué pasa con los hilos del demonio?

Los subprocesos del demonio son subprocesos de baja prioridad que brindan soporte y servicios en segundo plano a los subprocesos de usuario. La JVM finaliza automáticamente el subproceso del demonio si el programa permanece solo con el subproceso del demonio y todos los demás subprocesos del usuario finalizan o mueren. Hay dos métodos para subprocesos de demonio disponibles en la clase Thread:

setDaemon público vacío (estado booleano):Solía ​​​​marcar el hilo del demonio del hilo o un hilo del usuario.booleano público esDaemon():Comprueba que el hilo sea demonio o no.

18) ¿Podemos convertir el hilo de usuario en un hilo de demonio si se inicia el hilo?

No, si lo hace, arrojará IllegalThreadStateException. Por lo tanto, solo podemos crear un hilo de demonio antes de iniciar el hilo.

matriz de bytes a cadena

 class Testdaemon1 extends Thread{ public void run(){ System.out.println('Running thread is daemon...'); } public static void main (String[] args) { Testdaemon1 td= new Testdaemon1(); td.start(); setDaemon(true);// It will throw the exception: td. } } 

Producción

 Running thread is daemon... Exception in thread 'main' java.lang.IllegalThreadStateException at java.lang.Thread.setDaemon(Thread.java:1359) at Testdaemon1.main(Testdaemon1.java:8) 

19) ¿Qué es el gancho de apagado?

El gancho de apagado es un hilo que se invoca implícitamente antes de que se cierre JVM. Por lo tanto, podemos usarlo para realizar una limpieza del recurso o guardar el estado cuando JVM se apaga de forma normal o abrupta. Podemos agregar un gancho de apagado utilizando el siguiente método:

 public�void�addShutdownHook(Thread�hook){}�� Runtime r=Runtime.getRuntime(); r.addShutdownHook(new MyThread()); 

Algunos puntos importantes sobre los ganchos de apagado son:

• Los ganchos de apagado se inicializaron pero solo se pueden iniciar cuando se produjo el apagado de JVM.
• Los ganchos de apagado son más confiables que el finalizer() porque hay muy pocas posibilidades de que los ganchos de apagado no se ejecuten.
• El gancho de apagado se puede detener llamando al método halt(int) de la clase Runtime.

20)¿Cuándo debemos interrumpir un hilo?

Deberíamos interrumpir un hilo cuando queramos interrumpir el estado de suspensión o espera de un hilo. Podemos interrumpir un hilo llamando a la interrupción(), lanzando la InterruptedException.

21) ¿Qué es la sincronización?

La sincronización es la capacidad de controlar el acceso de múltiples subprocesos a cualquier recurso compartido. Esta usado:

1. Para evitar interferencias con el hilo.
2. Para evitar problemas de consistencia.

Cuando varios subprocesos intentan realizar la misma tarea, existe la posibilidad de obtener un resultado erróneo; por lo tanto, para eliminar este problema, Java utiliza el proceso de sincronización que permite que solo se ejecute un subproceso a la vez. La sincronización se puede lograr de tres maneras:

• por el método sincronizado
• por bloque sincronizado
• por sincronización estática

Sintaxis para bloque sincronizado

 synchronized(object reference expression) { //code block } 

22) ¿Cuál es el propósito del bloque Sincronizado?

El bloque Sincronizado se puede utilizar para realizar la sincronización en cualquier recurso específico del método. Sólo un subproceso a la vez puede ejecutarse en un recurso en particular, y todos los demás subprocesos que intentan ingresar al bloque sincronizado se bloquean.

• El bloque sincronizado se utiliza para bloquear un objeto para cualquier recurso compartido.
• El alcance del bloque sincronizado se limita al bloque en el que se aplica. Su alcance es menor que el de un método.

23) ¿Se puede bloquear el objeto Java para uso exclusivo de un hilo determinado?

Sí. Puedes bloquear un objeto colocándolo en un bloque 'sincronizado'. El objeto bloqueado es inaccesible para cualquier hilo que no sea el que lo reclamó explícitamente.

24) ¿Qué es la sincronización estática?

Si sincroniza algún método estático, el bloqueo estará en la clase, no en el objeto. Si usamos la palabra clave sincronizada antes de un método, bloqueará el objeto (un hilo puede acceder a un objeto a la vez), pero si usamos sincronización estática, bloqueará una clase (un hilo puede acceder a una clase a la vez). Más detalles.

lista a matriz java

25) ¿Cuál es la diferencia entre notificar() y notificar a todos()?

Notify() se usa para desbloquear un hilo en espera, mientras que el método notifyAll() se usa para desbloquear todos los hilos en estado de espera.

26)¿Qué es el punto muerto?

Un punto muerto es una situación en la que cada subproceso está esperando un recurso que está retenido por otro subproceso en espera. En esta situación, ninguno de los subprocesos se ejecuta ni tiene la oportunidad de ser ejecutado. En cambio, existe un estado de espera universal entre todos los hilos. El punto muerto es una situación muy complicada que puede romper nuestro código en tiempo de ejecución.

27) ¿Cómo detectar una condición de punto muerto? ¿Cómo se puede evitar?

Podemos detectar la condición de punto muerto ejecutando el código en cmd y recopilando el volcado de subprocesos, y si hay algún punto muerto en el código, aparecerá un mensaje en cmd.

Formas de evitar la condición de punto muerto en Java:

Evite el bloqueo anidado:El bloqueo anidado es la razón común para el interbloqueo, ya que el interbloqueo ocurre cuando proporcionamos bloqueos a varios subprocesos, por lo que debemos otorgar un bloqueo a un solo subproceso en un momento determinado.Evite bloqueos innecesarios:debemos evitar las cerraduras que no son necesarias.Usando unión de subprocesos:La unión de subprocesos ayuda a esperar un subproceso hasta que otro subproceso no finalice su ejecución para que podamos evitar el punto muerto mediante el uso máximo del método de unión.

28) ¿Qué es el Programador de subprocesos en Java?

En Java, cuando creamos los subprocesos, se supervisan con la ayuda de un Programador de subprocesos, que es parte de JVM. El programador de subprocesos solo es responsable de decidir qué subproceso se debe ejecutar. El programador de subprocesos utiliza dos mecanismos para programar los subprocesos: preventivo y de división de tiempo.

• Selecciona la prioridad del hilo.
• Determina el tiempo de espera de un hilo.
• Comprueba la naturaleza del hilo.

29) ¿Cada subproceso tiene su pila en la programación multiproceso?

Sí, en la programación multiproceso, cada subproceso mantiene su propia área de pila separada en la memoria, por lo que cada subproceso es independiente entre sí.

30) ¿Cómo se logra la seguridad de un hilo?

Si varios subprocesos pueden utilizar un método u objeto de clase a la vez sin ninguna condición de carrera, entonces la clase es segura para subprocesos. La seguridad de subprocesos se utiliza para hacer que un programa sea seguro de usar en programación multiproceso. Se puede lograr de las siguientes maneras:

• Sincronización
• Usando palabra clave volátil
• Usando un mecanismo basado en cerradura
• Uso de clases de envoltura atómica.

31) ¿Qué es la condición de carrera?

Una condición de carrera es un problema que ocurre en la programación multiproceso cuando varios subprocesos se ejecutan simultáneamente accediendo a un recurso compartido al mismo tiempo. El uso adecuado de la sincronización puede evitar la condición de carrera.

32) ¿Cuál es la palabra clave volátil en Java?

La palabra clave volátil se utiliza en la programación multiproceso para lograr la seguridad de los subprocesos, ya que un cambio en una variable volátil es visible para todos los demás subprocesos, por lo que un subproceso puede utilizar una variable a la vez.

33) ¿Qué entiendes por grupo de subprocesos?

• El grupo de subprocesos de Java representa un grupo de subprocesos de trabajo que están esperando que se asigne la tarea.
• Los subprocesos en el grupo de subprocesos son supervisados ​​por el proveedor de servicios, que extrae un subproceso del grupo y le asigna un trabajo.
• Después de completar la tarea dada, el hilo volvió al grupo de hilos.
• El tamaño del grupo de subprocesos depende del número total de subprocesos que se mantienen en reserva para su ejecución.

Las ventajas del grupo de subprocesos son:

• Al utilizar un grupo de subprocesos, se puede mejorar el rendimiento.
• Al utilizar un grupo de subprocesos, se puede lograr una mejor estabilidad del sistema.

Preguntas de la entrevista de simultaneidad

34) ¿Cuáles son los componentes principales de la API de concurrencia?

La API de concurrencia se puede desarrollar utilizando la clase y las interfaces del paquete java.util.Concurrent. Existen las siguientes clases e interfaces en el paquete java.util.Concurrent.

• Ejecutor
• FarkJoinPool
• Servicio Ejecutor
• Servicio de ejecución programado
• Futuro
• Unidad de tiempo(Enumeración)
• cuenta atrás
• Barrera cíclica
• Semáforo
• fábrica de hilos
• Cola de bloqueo
• DelayQueue
• Cerraduras
• fáser

35) ¿Qué es la interfaz Ejecutor en la API de concurrencia en Java?

La interfaz de ejecución proporcionada por el paquete java.util.concurrent es la interfaz simple utilizada para ejecutar la nueva tarea. El método ejecutar () de la interfaz Executor se utiliza para ejecutar algún comando determinado. La sintaxis del método ejecutar() se proporciona a continuación.

ejecución nula (comando ejecutable)

Considere el siguiente ejemplo:

 import java.util.concurrent.Executor; import java.util.concurrent.Executors; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { Executor e = Executors.newCachedThreadPool(); e.execute(new Thread()); ThreadPoolExecutor pool = (ThreadPoolExecutor)e; pool.shutdown(); } static class Thread implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 5); System.out.println('Running Thread!'); TimeUnit.SECONDS.sleep(duration); System.out.println('Thread Completed'); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } 

Producción

 Running Thread! Thread Completed 

36) ¿Qué es BlockingQueue?

java.util.concurrent.BlockingQueue es la subinterfaz de Queue que admite operaciones como esperar la disponibilidad de espacio antes de insertar un nuevo valor o esperar a que la cola no esté vacía antes de recuperar un elemento de ella. Considere el siguiente ejemplo.

 import java.util.Random; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { BlockingQueue queue = new ArrayBlockingQueue(10); Insert i = new Insert(queue); Retrieve r = new Retrieve(queue); new Thread(i).start(); new Thread(r).start(); Thread.sleep(2000); } static class Insert implements Runnable { private BlockingQueue queue; public Insert(BlockingQueue queue) { this.queue = queue; } @Override public void run() { Random random = new Random(); try { int result = random.nextInt(200); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); result = random.nextInt(10); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); result = random.nextInt(50); Thread.sleep(1000); queue.put(result); System.out.println('Added: ' + result); } catch (InterruptedException e) { e.printStackTrace(); } } } static class Retrieve implements Runnable { private BlockingQueue queue; public Retrieve(BlockingQueue queue) { this.queue = queue; } @Override public void run() { try { System.out.println('Removed: ' + queue.take()); System.out.println('Removed: ' + queue.take()); System.out.println('Removed: ' + queue.take()); } catch (InterruptedException e) { e.printStackTrace(); } } } } 

Producción

 Added: 96 Removed: 96 Added: 8 Removed: 8 Added: 5 Removed: 5 

37) ¿Cómo implementar el problema productor-consumidor utilizando BlockingQueue?

El problema productor-consumidor se puede resolver utilizando BlockingQueue de la siguiente manera.

 import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.logging.Level; import java.util.logging.Logger; public class ProducerConsumerProblem { public static void main(String args[]){ //Creating shared object BlockingQueue sharedQueue = new LinkedBlockingQueue(); //Creating Producer and Consumer Thread Thread prod = new Thread(new Producer(sharedQueue)); Thread cons = new Thread(new Consumer(sharedQueue)); //Starting producer and Consumer thread prod.start(); cons.start(); } } //Producer Class in java class Producer implements Runnable { private final BlockingQueue sharedQueue; public Producer(BlockingQueue sharedQueue) { this.sharedQueue = sharedQueue; } @Override public void run() { for(int i=0; i<10; i++){ try { system.out.println('produced: ' + i); sharedqueue.put(i); } catch (interruptedexception ex) logger.getlogger(producer.class.getname()).log(level.severe, null, ex); consumer class in java implements runnable{ private final blockingqueue sharedqueue; public (blockingqueue sharedqueue) this.sharedqueue="sharedQueue;" @override void run() while(true){ system.out.println('consumed: '+ sharedqueue.take()); logger.getlogger(consumer.class.getname()).log(level.severe, < pre> <p> <strong>Output</strong> </p> <pre> Produced: 0 Produced: 1 Produced: 2 Produced: 3 Produced: 4 Produced: 5 Produced: 6 Produced: 7 Produced: 8 Produced: 9 Consumed: 0 Consumed: 1 Consumed: 2 Consumed: 3 Consumed: 4 Consumed: 5 Consumed: 6 Consumed: 7 Consumed: 8 Consumed: 9 </pre> <hr> <h3>38) What is the difference between Java Callable interface and Runnable interface?</h3> <p>The Callable interface and Runnable interface both are used by the classes which wanted to execute with multiple threads. However, there are two main differences between the both : </p> <ul> <li>A Callable interface can return a result, whereas the Runnable interface cannot return any result.</li> <li>A Callable interface can throw a checked exception, whereas the Runnable interface cannot throw checked exception. </li> <li>A Callable interface cannot be used before the Java 5 whereas the Runnable interface can be used.</li> </ul> <hr> <h3>39) What is the Atomic action in Concurrency in Java?</h3> <ul> <li>The Atomic action is the operation which can be performed in a single unit of a task without any interference of the other operations.</li> <li>The Atomic action cannot be stopped in between the task. Once started it fill stop after the completion of the task only. </li> <li>An increment operation such as a++ does not allow an atomic action.</li> <li>All reads and writes operation for the primitive variable (except long and double) are the atomic operation.</li> <li>All reads and writes operation for the volatile variable (including long and double) are the atomic operation.</li> <li>The Atomic methods are available in java.util.Concurrent package. </li> </ul> <hr> <h3>40) What is lock interface in Concurrency API in Java?</h3> <p>The java.util.concurrent.locks.Lock interface is used as the synchronization mechanism. It works similar to the synchronized block. There are a few differences between the lock and synchronized block that are given below.</p> <ul> <li>Lock interface provides the guarantee of sequence in which the waiting thread will be given the access, whereas the synchronized block doesn&apos;t guarantee it.</li> <li>Lock interface provides the option of timeout if the lock is not granted whereas the synchronized block doesn&apos;t provide that.</li> <li>The methods of Lock interface, i.e., Lock() and Unlock() can be called in different methods whereas single synchronized block must be fully contained in a single method.</li> </ul> <hr> <h3>41) Explain the ExecutorService Interface.</h3> <p>The ExecutorService Interface is the subinterface of Executor interface and adds the features to manage the lifecycle. Consider the following example.</p> <pre> import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { ExecutorService e = Executors.newSingleThreadExecutor(); try { e.submit(new Thread()); System.out.println(&apos;Shutdown executor&apos;); e.shutdown(); e.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ex) { System.err.println(&apos;tasks interrupted&apos;); } finally { if (!e.isTerminated()) { System.err.println(&apos;cancel non-finished tasks&apos;); } e.shutdownNow(); System.out.println(&apos;shutdown finished&apos;); } } static class Task implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 20); System.out.println(&apos;Running Task!&apos;); TimeUnit.SECONDS.sleep(duration); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } </pre> <p> <strong>Output</strong> </p> <pre> Shutdown executor shutdown finished </pre> <hr> <h3>42) What is the difference between Synchronous programming and Asynchronous programming regarding a thread?</h3> <p> <strong>Synchronous programming: </strong> In Synchronous programming model, a thread is assigned to complete a task and hence thread started working on it, and it is only available for other tasks once it will end the assigned task.</p> <p> <strong>Asynchronous Programming: </strong> In Asynchronous programming, one job can be completed by multiple threads and hence it provides maximum usability of the various threads.</p> <hr> <h3>43) What do you understand by Callable and Future in Java?</h3> <p> <strong>Java Callable interface: </strong> In Java5 callable interface was provided by the package java.util.concurrent. It is similar to the Runnable interface but it can return a result, and it can throw an Exception. It also provides a run() method for execution of a thread. Java Callable can return any object as it uses Generic.</p> <p> <strong>Syntax:</strong> </p> <p>public interface Callable</p> <p> <strong>Java Future interface:</strong> Java Future interface gives the result of a concurrent process. The Callable interface returns the object of java.util.concurrent.Future.</p> <p>Java Future provides following methods for implementation.</p> <ul> <tr><td>cancel(boolean&#xFFFD;mayInterruptIfRunning):</td> It is used to cancel the execution of the assigned task. </tr><tr><td>get():</td> It waits for the time if execution not completed and then retrieved the result. </tr><tr><td>isCancelled():</td> It returns the Boolean value as it returns true if the task was canceled before the completion. </tr><tr><td>isDone():</td> It returns true if the job is completed successfully else returns false. </tr></ul> <hr> <h3>44. What is the difference between ScheduledExecutorService and ExecutorService interface?</h3> <p>ExecutorServcie and ScheduledExecutorService both are the interfaces of java.util.Concurrent package but scheduledExecutorService provides some additional methods to execute the Runnable and Callable tasks with the delay or every fixed time period.</p> <h3>45) Define FutureTask class in Java? </h3> <p>Java FutureTask class provides a base implementation of the Future interface. The result can only be obtained if the execution of one task is completed, and if the computation is not achieved then get method will be blocked. If the execution is completed, then it cannot be re-started and can&apos;t be canceled.</p> <p> <strong>Syntax</strong> </p> <p>public class FutureTask extends Object implements RunnableFuture</p> <hr></10;>

38) ¿Cuál es la diferencia entre la interfaz invocable de Java y la interfaz ejecutable?

La interfaz Callable y la interfaz Runnable son utilizadas por las clases que querían ejecutar con múltiples subprocesos. Sin embargo, existen dos diferencias principales entre ambos:

• Una interfaz invocable puede devolver un resultado, mientras que la interfaz ejecutable no puede devolver ningún resultado.
• Una interfaz invocable puede generar una excepción marcada, mientras que la interfaz Runnable no puede generar una excepción marcada.
• No se puede utilizar una interfaz invocable antes de Java 5, mientras que se puede utilizar la interfaz Runnable.

39) ¿Qué es la acción Atómica en Concurrencia en Java?

• La acción atómica es la operación que se puede realizar en una sola unidad de una tarea sin ninguna interferencia de las otras operaciones.
• La acción atómica no se puede detener entre tareas. Una vez iniciado, el llenado se detiene solo después de completar la tarea.
• Una operación de incremento como a++ no permite una acción atómica.
• Todas las operaciones de lectura y escritura de la variable primitiva (excepto larga y doble) son operaciones atómicas.
• Todas las operaciones de lectura y escritura de la variable volátil (incluidas las largas y las dobles) son operaciones atómicas.
• Los métodos atómicos están disponibles en el paquete java.util.Concurrent.

40) ¿Qué es la interfaz de bloqueo en la API de concurrencia en Java?

La interfaz java.util.concurrent.locks.Lock se utiliza como mecanismo de sincronización. Funciona de manera similar al bloque sincronizado. Existen algunas diferencias entre el bloqueo y el bloque sincronizado que se detallan a continuación.

• La interfaz de bloqueo proporciona la garantía de la secuencia en la que se le dará acceso al hilo en espera, mientras que el bloque sincronizado no lo garantiza.
• La interfaz de bloqueo proporciona la opción de tiempo de espera si no se concede el bloqueo, mientras que el bloque sincronizado no lo proporciona.
• Los métodos de la interfaz Lock, es decir, Lock() y Unlock() se pueden llamar en diferentes métodos, mientras que un único bloque sincronizado debe estar completamente contenido en un único método.

41) Explique la interfaz ExecutorService.

La interfaz ExecutorService es la subinterfaz de la interfaz Executor y agrega las funciones para administrar el ciclo de vida. Considere el siguiente ejemplo.

 import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; public class TestThread { public static void main(final String[] arguments) throws InterruptedException { ExecutorService e = Executors.newSingleThreadExecutor(); try { e.submit(new Thread()); System.out.println('Shutdown executor'); e.shutdown(); e.awaitTermination(5, TimeUnit.SECONDS); } catch (InterruptedException ex) { System.err.println('tasks interrupted'); } finally { if (!e.isTerminated()) { System.err.println('cancel non-finished tasks'); } e.shutdownNow(); System.out.println('shutdown finished'); } } static class Task implements Runnable { public void run() { try { Long duration = (long) (Math.random() * 20); System.out.println('Running Task!'); TimeUnit.SECONDS.sleep(duration); } catch (InterruptedException ex) { ex.printStackTrace(); } } } } 

Producción

 Shutdown executor shutdown finished 

42) ¿Cuál es la diferencia entre programación síncrona y programación asincrónica con respecto a un hilo?

Programación sincrónica: En el modelo de programación síncrona, se asigna un subproceso para completar una tarea y, por lo tanto, el subproceso comienza a trabajar en ella y solo está disponible para otras tareas una vez que finaliza la tarea asignada.

Programación asincrónica: En la programación asincrónica, un trabajo puede ser completado por varios subprocesos y, por lo tanto, proporciona la máxima usabilidad de los distintos subprocesos.

43) ¿Qué entiendes por Callable y Future en Java?

Interfaz invocable de Java: En Java5, la interfaz invocable la proporcionaba el paquete java.util.concurrent. Es similar a la interfaz Runnable pero puede devolver un resultado y puede generar una excepción. También proporciona un método run() para la ejecución de un hilo. Java Callable puede devolver cualquier objeto ya que usa Generic.

Sintaxis:

interfaz pública invocable

Interfaz futura de Java: La interfaz Java Future proporciona el resultado de un proceso concurrente. La interfaz invocable devuelve el objeto java.util.concurrent.Future.

cómo crear una matriz en java

Java Future proporciona los siguientes métodos de implementación.

cancelar(boolean�mayInterruptIfRunning):Se utiliza para cancelar la ejecución de la tarea asignada.conseguir():Espera el tiempo si la ejecución no se completó y luego recupera el resultado.está cancelado():Devuelve el valor booleano ya que devuelve verdadero si la tarea se canceló antes de completarse.está hecho():Devuelve verdadero si el trabajo se completa con éxito; de lo contrario, devuelve falso.

44. ¿Cuál es la diferencia entre la interfaz ScheduledExecutorService y ExecutorService?

ExecutorServcie y ScheduledExecutorService son las interfaces del paquete java.util.Concurrent, pero ScheduledExecutorService proporciona algunos métodos adicionales para ejecutar las tareas Runnable y Callable con retraso o cada período de tiempo fijo.

45) ¿Definir la clase FutureTask en Java?

La clase Java FutureTask proporciona una implementación básica de la interfaz Future. El resultado solo se puede obtener si se completa la ejecución de una tarea, y si no se logra el cálculo, se bloqueará el método get. Si se completa la ejecución, no se puede reiniciar ni cancelar.

Sintaxis

la clase pública FutureTask extiende el objeto implementa RunnableFuture