TechCodeview

Le multithreading et la synchronisation sont considérés comme le chapitre typique de la programmation Java. Dans les sociétés de développement de jeux, les questions d'entretien liées au multithreading sont principalement posées. Une liste des questions d'entretien fréquemment posées sur le multithreading Java et la concurrence est donnée ci-dessous.

Questions d'entretien multithread

1) Qu’est-ce que le multithreading ?

Le multithreading est un processus d'exécution de plusieurs threads simultanément. Le multithreading est utilisé pour obtenir le multitâche. Il consomme moins de mémoire et offre des performances rapides et efficaces. Ses principaux avantages sont :

• Les threads partagent le même espace d’adressage.
• Le fil est léger.
• Le coût de la communication entre les processus est faible.

2) Quel est le fil conducteur ?

Un thread est un sous-processus léger. Il s'agit d'un chemin d'exécution distinct car chaque thread s'exécute dans un cadre de pile différent. Un processus peut contenir plusieurs threads. Les threads partagent les ressources du processus, mais ils s’exécutent néanmoins indépendamment.

3) Faire la différence entre processus et thread ?

Il existe les différences suivantes entre le processus et le thread.

• Un programme en exécution est appelé le processus alors que ; Un thread est un sous-ensemble du processus
• Les processus sont indépendants alors que les threads sont le sous-ensemble du processus.
• Les processus ont un espace d'adressage différent en mémoire, tandis que les threads contiennent un espace d'adressage partagé.
• Le changement de contexte est plus rapide entre les threads qu’entre les processus.
• La communication inter-processus est plus lente et coûteuse que la communication inter-thread.
• Toute modification du processus parent n'affecte pas le processus enfant, tandis que les modifications apportées au thread parent peuvent affecter le thread enfant.

4) Qu’entendez-vous par communication inter-thread ?

• Le processus de communication entre les threads synchronisés est appelé communication inter-thread.
• La communication inter-thread est utilisée pour éviter l'interrogation des threads en Java.
• Le thread est mis en pause dans sa section critique et un autre thread est autorisé à entrer (ou à se verrouiller) dans la même section critique pour être exécuté.
• Il peut être obtenu par les méthodes wait(), notify() et notifyAll().

5) Quel est le but de la méthode wait() en Java ?

La méthode wait() est fournie par la classe Object en Java. Cette méthode est utilisée pour la communication inter-thread en Java. Le java.lang.Object.wait() est utilisé pour mettre en pause le thread en cours et attendre qu'un autre thread n'appelle pas la méthode notify() ou notifyAll(). Sa syntaxe est donnée ci-dessous.

public final void wait()

6) Pourquoi la méthode wait() doit-elle être appelée depuis le bloc synchronisé ?

Nous devons appeler la méthode wait sinon elle lancera java.lang.IllegalMonitorStateException exception. De plus, nous avons besoin de la méthode wait() pour la communication inter-thread avec notify() et notifyAll(). Par conséquent, il doit être présent dans le bloc synchronisé pour une communication appropriée et correcte.

7) Quels sont les avantages du multithreading ?

La programmation multithread présente les avantages suivants :

• Le multithreading permet à une application/un programme d'être toujours réactif aux entrées, même déjà en cours d'exécution avec certaines tâches en arrière-plan
• Le multithreading permet une exécution plus rapide des tâches, car les threads s'exécutent indépendamment.
• Le multithreading permet une meilleure utilisation de la mémoire cache car les threads partagent les ressources mémoire communes.
• Le multithreading réduit le nombre de serveurs requis car un serveur peut exécuter plusieurs threads à la fois.

8) Quels sont les états dans le cycle de vie d’un Thread ?

Un thread peut avoir l'un des états suivants au cours de sa durée de vie :

Nouveau:Dans cet état, un objet de classe Thread est créé à l’aide d’un nouvel opérateur, mais le thread n’est pas actif. Le thread ne démarre pas tant que nous n’appelons pas la méthode start().Exécutable :Dans cet état, le thread est prêt à s’exécuter après avoir appelé la méthode start(). Cependant, le thread n'est pas encore sélectionné par le planificateur de threads.En cours d'exécution:Dans cet état, le planificateur de thread sélectionne le thread dans l'état prêt et le thread est en cours d'exécution.En attente/bloqué :Dans cet état, un thread n'est pas en cours d'exécution mais est toujours actif, ou il attend la fin de l'autre thread.Mort/Terminé :Un thread est dans un état terminé ou mort lorsque la méthode run() se termine.

9) Quelle est la différence entre la planification préemptive et le découpage temporel ?

Dans le cadre de la planification préemptive, la tâche la plus prioritaire s'exécute jusqu'à ce qu'elle entre dans l'état d'attente ou mort ou qu'une tâche de priorité plus élevée apparaisse. Dans le cadre du découpage temporel, une tâche s'exécute pendant une tranche de temps prédéfinie, puis réintègre le pool de tâches prêtes. Le planificateur détermine ensuite quelle tâche doit être exécutée ensuite, en fonction de la priorité et d'autres facteurs.

10) Qu'est-ce que le changement de contexte ?

Dans le changement de contexte, l'état du processus (ou du thread) est stocké afin qu'il puisse être restauré et que l'exécution puisse être reprise ultérieurement au même point. La commutation de contexte permet à plusieurs processus de partager le même processeur.

11) Faire la différence entre la classe Thread et l'interface Runnable pour créer un Thread ?

Le fil de discussion peut être créé de deux manières.

• En étendant la classe Thread
• En implémentant l'interface Runnable

Cependant, les principales différences entre les deux méthodes sont indiquées ci-dessous :

• En étendant la classe Thread, nous ne pouvons étendre aucune autre classe, car Java n'autorise pas les héritages multiples lors de l'implémentation de l'interface Runnable ; nous pouvons également étendre une autre classe de base (si nécessaire).
• En étendant la classe Thread, chacun des threads crée l'objet unique et s'y associe lors de l'implémentation de l'interface Runnable ; plusieurs threads partagent le même objet
• La classe Thread fournit diverses méthodes intégrées telles que getPriority(), isAlive et bien d'autres, tandis que l'interface Runnable fournit une seule méthode, à savoir run().

12) Qu'est-ce que la méthode join() ?

La méthode join() attend la mort d’un thread. En d’autres termes, les threads en cours d’exécution arrêtent de s’exécuter jusqu’à ce que le thread auquel il se joint termine sa tâche. La méthode Join est surchargée dans la classe Thread des manières suivantes.

• public void join() lance InterruptedException
• la jointure public void (longues millisecondes) lève une exception InterruptedException

13) Décrivez le but et le fonctionnement de la méthode sleep().

La méthode sleep() en Java est utilisée pour bloquer un thread pendant une heure particulière, ce qui signifie qu'elle suspend l'exécution d'un thread pendant une heure spécifique. Il existe deux méthodes pour le faire.

Syntaxe:

uri contre URL

• le sommeil vide statique public (longues millisecondes) lève une exception InterruptedException
• le sommeil vide statique public (longues millisecondes, nanos int) lance une exception InterruptedException

Fonctionnement de la méthode sleep()

Lorsque nous appelons la méthode sleep(), elle suspend l'exécution du thread en cours pendant le temps imparti et donne la priorité à un autre thread (si disponible). De plus, lorsque le temps d'attente est terminé, le thread précédent change à nouveau son état d'attente à exécutable et passe à l'état d'exécution, et l'ensemble du processus fonctionne ainsi jusqu'à ce que l'exécution ne soit pas terminée.

14) Quelle est la différence entre les méthodes wait() et sleep() ?

15) Est-il possible de démarrer un fil de discussion deux fois ?

Non, nous ne pouvons pas redémarrer le thread, car une fois qu'un thread est démarré et exécuté, il passe à l'état Dead. Par conséquent, si nous essayons de démarrer un thread deux fois, cela donnera une runtimeException 'java.lang.IllegalThreadStateException'. Considérez l'exemple suivant.

 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(); } } 

Sortir

 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) Pouvons-nous appeler la méthode run() au lieu de start() ?

Oui, appeler directement la méthode run() est valide, mais cela ne fonctionnera pas comme un thread mais fonctionnera comme un objet normal. Il n’y aura pas de changement de contexte entre les threads. Lorsque nous appelons la méthode start(), elle appelle en interne la méthode run(), qui crée une nouvelle pile pour un thread tout en appelant directement run() ne créera pas de nouvelle pile.

mot-clé final en Java

17) Qu’en est-il des threads démons ?

Les threads démons sont les threads de faible priorité qui fournissent la prise en charge et les services en arrière-plan aux threads utilisateur. Le thread démon est automatiquement terminé par la JVM si le programme reste uniquement avec le thread démon et que tous les autres threads utilisateur sont terminés/morts. Il existe deux méthodes pour les threads démons disponibles dans la classe Thread :

public void setDaemon (statut booléen) :Il était utilisé pour marquer le thread du démon de thread ou un thread utilisateur.public booléen isDaemon() :Il vérifie que le thread est démon ou non.

18) Pouvons-nous faire du thread utilisateur un thread démon si le thread est démarré ?

Non, si vous le faites, cela lancera IllegalThreadStateException. Par conséquent, nous ne pouvons créer un thread démon qu’avant de démarrer le thread.

 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. } } 

Sortir

 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’est-ce que le crochet d’arrêt ?

Le hook d'arrêt est un thread qui est invoqué implicitement avant l'arrêt de la JVM. Nous pouvons donc l'utiliser pour effectuer un nettoyage de la ressource ou enregistrer l'état lorsque la JVM s'arrête normalement ou brusquement. Nous pouvons ajouter un hook d'arrêt en utilisant la méthode suivante :

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

Voici quelques points importants concernant les hooks d'arrêt :

• Les hooks d'arrêt sont initialisés mais ne peuvent être démarrés que lorsque l'arrêt de la JVM s'est produit.
• Les hooks d'arrêt sont plus fiables que finalizer() car il y a très moins de chances que les hooks d'arrêt ne s'exécutent pas.
• Le hook d'arrêt peut être arrêté en appelant la méthode halt(int) de la classe Runtime.

20)Quand doit-on interrompre un fil de discussion ?

Nous devons interrompre un thread lorsque nous voulons sortir de l'état de veille ou d'attente d'un thread. Nous pouvons interrompre un thread en appelant l'interruption() en lançant l'InterruptedException.

21) Qu'est-ce que la synchronisation ?

La synchronisation est la capacité de contrôler l'accès de plusieurs threads à n'importe quelle ressource partagée. C'est utilisé:

1. Pour éviter les interférences de filetage.
2. Pour éviter les problèmes de cohérence.

Lorsque plusieurs threads tentent d'effectuer la même tâche, il existe une possibilité d'obtention d'un résultat erroné. Par conséquent, pour supprimer ce problème, Java utilise le processus de synchronisation qui permet d'exécuter un seul thread à la fois. La synchronisation peut être réalisée de trois manières :

• par la méthode synchronisée
• par bloc synchronisé
• par synchronisation statique

Syntaxe du bloc synchronisé

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

22) A quoi sert le bloc Synchronisé ?

Le bloc Synchronisé peut être utilisé pour effectuer une synchronisation sur n’importe quelle ressource spécifique de la méthode. Un seul thread à la fois peut s'exécuter sur une ressource particulière, et tous les autres threads qui tentent d'entrer dans le bloc synchronisé sont bloqués.

• Le bloc synchronisé est utilisé pour verrouiller un objet pour toute ressource partagée.
• La portée du bloc synchronisé est limitée au bloc sur lequel il est appliqué. Sa portée est plus petite qu’une méthode.

23) Un objet Java peut-il être verrouillé pour une utilisation exclusive par un thread donné ?

Oui. Vous pouvez verrouiller un objet en le plaçant dans un bloc « synchronisé ». L'objet verrouillé est inaccessible à tout thread autre que celui qui l'a explicitement revendiqué.

24) Qu'est-ce que la synchronisation statique ?

Si vous définissez une méthode statique comme synchronisée, le verrou sera sur la classe et non sur l'objet. Si nous utilisons le mot-clé synchronisé avant une méthode, il verrouillera l'objet (un thread peut accéder à un objet à la fois), mais si nous utilisons static synchronisé, il verrouillera une classe (un thread peut accéder à une classe à la fois). Plus de détails.

25)Quelle est la différence entre notify() et notifyAll() ?

La méthode notify() est utilisée pour débloquer un thread en attente tandis que la méthode notifyAll() est utilisée pour débloquer tous les threads en état d'attente.

26) Quelle est l’impasse ?

Un blocage est une situation dans laquelle chaque thread attend une ressource détenue par un autre thread en attente. Dans cette situation, aucun des threads ne s'exécute et n'a la possibilité d'être exécuté. Au lieu de cela, il existe un état d’attente universel parmi tous les threads. Le blocage est une situation très compliquée qui peut casser notre code au moment de l'exécution.

27) Comment détecter une condition de blocage ? comment ca peut etre evite?

Nous pouvons détecter la condition de blocage en exécutant le code sur cmd et en collectant le Thread Dump, et si un blocage est présent dans le code, un message apparaîtra sur cmd.

Façons d’éviter la condition de blocage en Java :

Évitez le verrouillage imbriqué :Le verrouillage imbriqué est la raison courante d'un blocage, car un blocage se produit lorsque nous fournissons des verrous à différents threads. Nous devons donc attribuer un verrou à un seul thread à un moment donné.Évitez les verrous inutiles :il faut éviter les serrures qui ne sont pas obligatoires.Utilisation de la jointure de thread :Thread join permet d'attendre un thread jusqu'à ce qu'un autre thread ne termine pas son exécution afin que nous puissions éviter les blocages en utilisant au maximum la méthode join.

28) Qu’est-ce que le planificateur de threads en Java ?

En Java, lorsque nous créons les threads, ils sont supervisés à l'aide d'un Thread Scheduler, qui fait partie de la JVM. Le planificateur de threads est uniquement responsable de décider quel thread doit être exécuté. Le planificateur de threads utilise deux mécanismes pour planifier les threads : préemptif et Time Slicing.

file d'attente prioritaire java

• Il sélectionne la priorité du thread.
• Il détermine le temps d'attente pour un fil
• Il vérifie la nature du fil

29) Chaque thread a-t-il sa pile en programmation multithread ?

Oui, dans la programmation multithread, chaque thread conserve sa propre zone de pile ou une zone de pile distincte en mémoire, grâce à laquelle chaque thread est indépendant les uns des autres.

30) Comment la sécurité d'un fil est-elle assurée ?

Si une méthode ou un objet de classe peut être utilisé par plusieurs threads à la fois sans aucune condition de concurrence critique, alors la classe est thread-safe. La sécurité des threads est utilisée pour rendre un programme sûr à utiliser dans la programmation multithread. Cela peut être réalisé des manières suivantes :

• Synchronisation
• Utilisation du mot clé Volatile
• Utiliser un mécanisme basé sur le verrouillage
• Utilisation de classes wrapper atomiques

31) Qu'est-ce que la condition de course ?

Une condition de concurrence est un problème qui se produit dans la programmation multithread lorsque plusieurs threads s'exécutent simultanément en accédant à une ressource partagée en même temps. L'utilisation appropriée de la synchronisation peut éviter la condition de course.

32) Quel est le mot clé volatile en Java ?

Le mot-clé Volatile est utilisé dans la programmation multithread pour assurer la sécurité des threads, car une modification dans une variable volatile est visible par tous les autres threads afin qu'une variable puisse être utilisée par un thread à la fois.

33) Qu’entendez-vous par pool de threads ?

• Le pool de threads Java représente un groupe de threads de travail qui attendent que la tâche soit allouée.
• Les threads du pool de threads sont supervisés par le fournisseur de services qui extrait un thread du pool et lui attribue une tâche.
• Après avoir terminé la tâche donnée, le thread est revenu au pool de threads.
• La taille du pool de threads dépend du nombre total de threads conservés en réserve pour l'exécution.

Les avantages du pool de threads sont :

• À l’aide d’un pool de threads, les performances peuvent être améliorées.
• L’utilisation d’un pool de threads permet d’obtenir une meilleure stabilité du système.

Questions d'entretien simultanées

34) Quels sont les principaux composants de l'API de concurrence ?

L'API de concurrence peut être développée à l'aide de la classe et des interfaces du package java.util.Concurrent. Il existe les classes et interfaces suivantes dans le package java.util.Concurrent.

• Exécuteur
• FarkRejoindrePool
• ExécuteurService
• Service d'exécution planifié
• Avenir
• Unité de temps (énumération)
• Compte à rebours
• Barrière cyclique
• Sémaphore
• Usine de discussions
• File d'attente de blocage
• Retarder la file d'attente
• Serrures
• Phaseur

35) Qu'est-ce que l'interface Executor dans l'API Concurrency en Java ?

L'interface Executor fournie par le package java.util.concurrent est l'interface simple utilisée pour exécuter la nouvelle tâche. La méthode execute() de l’interface Executor est utilisée pour exécuter une commande donnée. La syntaxe de la méthodeexecute() est donnée ci-dessous.

void exécuter (commande exécutable)

Prenons l'exemple suivant :

 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(); } } } } 

Sortir

 Running Thread! Thread Completed 

36) Qu'est-ce que BlockingQueue ?

Java.util.concurrent.BlockingQueue est la sous-interface de Queue qui prend en charge les opérations telles que l'attente de la disponibilité de l'espace avant d'insérer une nouvelle valeur ou l'attente que la file d'attente ne soit pas vide avant d'en récupérer un élément. Considérez l'exemple suivant.

 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(); } } } } 

Sortir

compter SQL distinct

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

37) Comment implémenter le problème producteur-consommateur en utilisant BlockingQueue ?

Le problème producteur-consommateur peut être résolu en utilisant BlockingQueue de la manière suivante.

 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) Quelle est la différence entre l’interface Java Callable et l’interface Runnable ?

L'interface Callable et l'interface Runnable sont toutes deux utilisées par les classes qui souhaitent s'exécuter avec plusieurs threads. Cependant, il existe deux différences principales entre les deux :

• Une interface Callable peut renvoyer un résultat, tandis que l'interface Runnable ne peut renvoyer aucun résultat.
• Une interface Callable peut lever une exception vérifiée, alors que l'interface Runnable ne peut pas lancer une exception vérifiée.
• Une interface Callable ne peut pas être utilisée avant Java 5 alors que l'interface Runnable peut être utilisée.

39) Qu'est-ce que l'action atomique dans la concurrence en Java ?

• L'action atomique est l'opération qui peut être effectuée dans une seule unité d'une tâche sans aucune interférence avec les autres opérations.
• L'action atomique ne peut pas être arrêtée entre deux tâches. Une fois démarré, le remplissage s'arrête uniquement après la fin de la tâche.
• Une opération d'incrémentation telle que a++ ne permet pas une action atomique.
• Toutes les opérations de lecture et d'écriture pour la variable primitive (sauf long et double) sont des opérations atomiques.
• Toutes les opérations de lecture et d'écriture pour la variable volatile (y compris les opérations longues et doubles) sont des opérations atomiques.
• Les méthodes atomiques sont disponibles dans le package java.util.Concurrent.

40) Qu'est-ce que l'interface de verrouillage dans l'API Concurrency en Java ?

L'interface java.util.concurrent.locks.Lock est utilisée comme mécanisme de synchronisation. Cela fonctionne de manière similaire au bloc synchronisé. Il existe quelques différences entre le verrouillage et le bloc synchronisé qui sont indiquées ci-dessous.

• L'interface de verrouillage fournit la garantie de la séquence dans laquelle le thread en attente recevra l'accès, alors que le bloc synchronisé ne le garantit pas.
• L'interface de verrouillage offre la possibilité d'expiration si le verrou n'est pas accordé alors que le bloc synchronisé ne le fournit pas.
• Les méthodes de l'interface Lock, c'est-à-dire Lock() et Unlock() peuvent être appelées dans différentes méthodes alors qu'un seul bloc synchronisé doit être entièrement contenu dans une seule méthode.

41) Expliquez l'interface ExecutorService.

L'interface ExecutorService est la sous-interface de l'interface Executor et ajoute les fonctionnalités permettant de gérer le cycle de vie. Considérez l'exemple suivant.

 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(); } } } } 

Sortir

 Shutdown executor shutdown finished 

42) Quelle est la différence entre la programmation synchrone et la programmation asynchrone concernant un thread ?

Programmation synchrone : Dans le modèle de programmation synchrone, un thread est chargé d'accomplir une tâche et, par conséquent, le thread a commencé à travailler dessus, et il n'est disponible pour d'autres tâches qu'une fois qu'il a terminé la tâche assignée.

Programmation asynchrone : Dans la programmation asynchrone, un travail peut être effectué par plusieurs threads et offre donc une convivialité maximale des différents threads.

43) Qu'entendez-vous par Callable et Future en Java ?

Interface appelable Java : En Java5, l'interface appelable était fournie par le package java.util.concurrent. Elle est similaire à l’interface Runnable mais elle peut renvoyer un résultat et lever une exception. Il fournit également une méthode run() pour l'exécution d'un thread. Java Callable peut renvoyer n'importe quel objet car il utilise Generic.

Syntaxe:

interface publique Appelable

Interface Java Future : L'interface Java Future donne le résultat d'un processus simultané. L'interface Callable renvoie l'objet de java.util.concurrent.Future.

Java Future fournit les méthodes d'implémentation suivantes.

Cancel(boolean�mayInterruptIfRunning) :Il permet d'annuler l'exécution de la tâche assignée.obtenir():Il attend l'heure si l'exécution n'est pas terminée, puis récupère le résultat.est annulé():Il renvoie la valeur booléenne car il renvoie vrai si la tâche a été annulée avant la fin.est fait():Il renvoie vrai si le travail est terminé avec succès, sinon renvoie faux.

44. Quelle est la différence entre les interfaces ScheduledExecutorService et ExecutorService ?

ExecutorServcie et ScheduledExecutorService sont tous deux les interfaces du package java.util.Concurrent, mais selectedExecutorService fournit des méthodes supplémentaires pour exécuter les tâches Runnable et Callable avec un délai ou à chaque période de temps fixe.

45) Définir la classe FutureTask en Java ?

La classe Java FutureTask fournit une implémentation de base de l'interface Future. Le résultat ne peut être obtenu que si l'exécution d'une tâche est terminée, et si le calcul n'est pas réalisé, la méthode get sera bloquée. Si l’exécution est terminée, elle ne peut pas être redémarrée ni annulée.

Syntaxe

la classe publique FutureTask étend l'objet implémente RunnableFuture