Questions d'entretien multithread en Java

En Java, le multithreading implique l'exécution simultanée de deux ou plusieurs threads, améliorant ainsi la vitesse du processus en fonction de la capacité du système. Le multithreading traite simultanément les plus petites unités, ce qui facilite une exécution plus rapide. Les développeurs l'utilisent pour des tâches telles que l'animation, les jeux et la gestion de grandes applications, contribuant ainsi à l'efficacité de l'espace mémoire et du temps.

Maintenant, si vous recherchez un emploi lié au multithreading en Java, vous devez vous préparer aux questions d'entretien multithreading en Java. Chaque entretien est en effet différent en fonction des profils d'emploi. Ici, nous avons préparé les questions d'entretien multithreading importantes en Java avec leurs réponses, qui vous aideront à réussir votre entretien.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Cet article présentera les 40 questions les plus importantes et les plus fréquemment posées sur les questions d'entretien multithread en Java.

Q1. Expliquez les différents états de Thread.

Réponse :
Les états du thread sont également appelés cycle de vie d'un thread. Ci-dessous se trouvent les différents états du Thread :

• • Nouveau : Cela signifie que le thread est dans un nouvel état et doit créer l'instance de la classe thread avant l'invocation de la méthode start.
  • Exécutable : Après avoir invoqué la méthode start, le thread est dans un état exécutable et le planificateur ne l'a pas sélectionné comme thread en cours d'exécution.
  • En cours d'exécution : Lorsque le planificateur de threads est sélectionné, il est en cours d'exécution.
  • Bloqué : il est également connu sous le nom de non-exécutable. Lorsque le fil de discussion n'est pas éligible, il est toujours actif.
  • Terminé : Il s'agit de l'état dans lequel il quitte la méthode d'exécution ou est à l'état mort.

Q2. Qu'est-ce que le fil de discussion en Java ?

Réponse : Le fil de discussion fait référence à une petite unité qui prend moins de temps à s'exécuter. Elle est essentiellement indépendante du chemin d’exécution. C'est l'un des moyens de profiter des multiples processeurs disponibles dans la machine. Avec l'aide de plusieurs threads, le processus de la tâche CPU devient plus rapide. Java est principalement utilisé pour prendre en charge le multithreading. Java prend en charge le multithreading pour tirer parti de plusieurs processeurs et améliorer les performances du programme. L'extension de la classe Thread ou l'implémentation de l'interface Runnable sont deux façons de créer des threads.

Q3. Expliquez la différence entre thread et processus en JAVA.

Réponse : Le thread est la plus petite tâche d'exécution au sein du processus. Le processus est un environnement d'exécution autonome comportant plus d'un ou plusieurs threads. Les threads sont la subdivision du processus. Le thread a un accès direct au segment de données du processus, tandis que le processus possède sa propre copie du segment de données. Thread partage principalement l'adresse créée par le processus, et le processus a sa propre adresse.

Le fil de discussion peut être facilement créé et la création de processus nécessite beaucoup de choses à faire. Le thread peut facilement communiquer avec d'autres threads, tandis que le processus peut facilement communiquer avec le processus enfant, mais la communication interprocessus est difficile. Le thread a sa propre pile, alors que le processus partage les ressources mémoire comme la mémoire tas, etc. Si une modification a été effectuée dans le thread, cela affectera tous les threads, mais dans le processus, cela n'affectera pas les autres processus.

Q4. Expliquez le modèle de mémoire Java.

Réponse : Voici les questions d'entretien multithread courantes en Java posées lors d'un entretien. Plusieurs responsabilités doivent normalement être assumées par un testeur multithreading dans l'industrie informatique actuelle.

Le modèle de mémoire Java établit un ensemble spécifique de règles auxquelles les programmes Java doivent adhérer afin d'afficher un comportement cohérent sur diverses architectures de mémoire, processeurs et systèmes d'exploitation. Ces règles jouent un rôle crucial dans le multithreading. Le modèle de mémoire Java permet de distinguer les modifications apportées dans l'un des threads, et ces modifications doivent également être visibles par les autres threads. Ce mod est un ordre de programme qui dit que l'action de chaque thread se produit avant que chaque thread n'arrive plus tard dans l'ordre du programme.

Q5. Expliquez l'utilisation des variables volatiles dans Java Multithreading.

Réponse : Le mot-clé ou la variable volatile garantit que les variables partagées ou d'instance reçoivent des mises à jour constantes chaque fois que plusieurs threads apportent des modifications. Il s'agit d'un modificateur spécial applicable uniquement aux variables d'instance, pas aux méthodes. Déclarer un champ comme volatile en Java garantit que le modèle de mémoire Java garantit des valeurs cohérentes pour cette variable dans tous les threads. Le programme lit toujours la valeur de la variable volatile dans la mémoire principale, réduisant ainsi le risque d'erreurs de cohérence de la mémoire. De plus, une variable volatile Java représentant une référence d'objet peut être nulle. L'application du mot-clé volatile est nécessaire lorsqu'une variable est utilisée sur plusieurs threads.

Q6. Expliquez la condition de concurrence dans les discussions.

Réponse : La condition de concurrence critique se produit lorsqu'il y a une course entre plusieurs threads. Cette condition de concurrence est principalement due à des bugs ou à des erreurs de programmation. Le thread qui doit être exécuté a d'abord perdu la course, puis a exécuté la seconde et a apporté quelques changements dans le comportement du code, appelés bogues non déterministes. Cela devient l'un des bugs difficiles à découvrir et à reproduire en raison de la nature aléatoire des discussions.

Q7. Expliquez le framework fork-join en Java.

Réponse : Le framework fork-join est introduit dans le JDK7. Il s’agit d’un outil puissant permettant aux développeurs Java de tirer parti des multiples processeurs des serveurs mondiaux d’aujourd’hui. Il est principalement conçu pour des travaux pouvant être divisés en morceaux plus petits. L'objectif principal est d'utiliser la puissance de traitement disponible pour augmenter les performances des applications. Il utilisait principalement l’algorithme de vol de travail.

Q8. Expliquez le pool de threads et son utilisation en Java.

Réponse : Le pool de threads est connu sous le nom de pool de threads. Le thread est généralement appelé thread de travail. La création d'un fil de discussion est coûteuse à bien des égards, en temps et en ressources. Lorsque vous créez le thread au moment de la demande du processus, cela ralentit généralement le temps de réponse du processeur et seule une certaine limite dans le nombre de threads peut être créée. Ainsi, à cause de ces deux problèmes majeurs, le pool de threads a été créé. En Java, l'API Java nous permet de créer différents types de pools de threads, comme un pool de threads unique, qui ne prend qu'un seul processus à la fois. L'autre est un pool de threads fixe qui prend un nombre fixe de threads. Ensuite, il existe un pool de threads en cache, un pool de threads extensible et principalement adapté à de nombreuses tâches.

Q9. Comment les données peuvent-elles être partagées entre les fils de discussion ?

Réponse : Ce sont les questions d'entretien multithread les plus populaires en Java posées lors d'un entretien. Quelques cas de test populaires dans l'industrie informatique actuelle.

Les données peuvent être partagées entre les threads à l'aide de l'objet partagé ou d'une structure de données concurrente comme une file d'attente de blocage. Il suit principalement le modèle producteur-consommateur en utilisant des méthodes d'attente et de notification qui impliquent le partage d'un objet entre les deux threads.

Q10. Comment les threads sont-ils distribués dans la mémoire de pile et de tas ?

Réponse : En Java, chaque thread possède sa propre pile, qui est utilisée pour stocker les variables locales, les paramètres de méthode et la pile d'appels. La mémoire tas est une mémoire commune partagée par tous les threads.

Q11. Distinguer un fil et un processus.

Réponse :

Feature	Process	Thread
Definition	An autonomous program running.	A process’s lightweight unit.
Execution	Operates on its own.	Operates within a process’s framework.
Communication	Requires communication between processes.	Communication made easier and data space shared.
Synchronization	More remote and possibly requiring more overhead.	Requires shared data synchronization mechanisms.
Resource Overhead	Greater (differing memory spaces).	Lower (shares the process’s resources).
Creation Time	Slower and requiring more resources.	Quicker and with less overhead needed.
Fault Tolerance	More resilient.	Failure could impact the entire process if it is not as strong.

Q12. A quoi sert la méthode Java wait() ?

Réponse : Java utilise les méthodes notify() et notifyAll() en conjonction avec la méthode wait() pour implémenter la synchronisation et la communication inter-thread. La classe Object, qui constitue la classe fondamentale de toutes les classes Java, contient ces méthodes. Syntaxe donnée ci-dessous :

public final void wait() throws InterruptedException

Cela signifie que si vous utilisez wait(), vous devez soit déclarer que la méthode qui appelle wait() lève cette exception, soit intercepter l'InterruptedException.

Q13. Faire la différence entre le Thread utilisateur et le Thread démon ?

Réponse : Un thread créé en Java est appelé un thread utilisateur. Un Daemon Thread s’exécute toujours en arrière-plan et son cycle de vie complet dépend du thread principal. Un thread démon exécuté en arrière-plan n’empêchera pas JVM d’y mettre fin. Le fil enfant créé à partir d'un fil démon sera également un fil démon.

Q14. Quelles sont les différentes manières de créer un Thread en Java ?

Réponse :
Les threads en Java peuvent être créés de deux manières :

• En étendant la classe Thread.

class MyThread extends Thread {
public void run() {
// Code to be executed in the new thread
}
}

// Creating and starting the thread
MyThread myThread = new MyThread();
myThread.start();

• En implémentant Runnable Interface.

class MyRunnable implements Runnable {
public void run() {
// Code to be executed in the new thread
}
}

// Creating a thread using the Runnable interface
Thread myThread = new Thread(new MyRunnable());
myThread.start();

Q15. Quel est le cycle de vie de Thread en JAVA ?

Réponse : Il existe des questions d'entretien Java courantes sur le multithreading posées lors d'un entretien. Voici le cycle de vie d'un fil :

• Nouveau
• Exécutable.
• Courir.
• Bloqué.
• Terminé.

Q16. Que se passe-t-il si nous appelons la méthode run() d'une classe Thread ?

Réponse : L'appel direct de la méthode run() compilera et exécutera le programme avec succès, mais le même programme ne sera pas traité comme Thread car aucune nouvelle pile d'appels ne sera créée et le programme démarre son exécution dans la même pile d'appels où le main est en cours d'exécution.

Pour créer un Thread qui doit s'exécuter avec une nouvelle pile d'appels, il faut utiliser la méthode start() de la classe Thread.

Q17. Pouvons-nous suspendre l'exécution d'un Thread à un moment précis ?

Réponse : Oui, cela peut être réalisé en Java en appelant le sleep() de la classe Thread. La méthode sleep() prend également un argument qui indique le temps en millisecondes.

Q18. Comment pouvons-nous réaliser la planification des threads en Java ?

Réponse : Oui, la planification de threads en Java est possible. Les threads en Java peuvent être planifiés de deux manières, à savoir le découpage temporel et la planification préemptive.

Passons aux prochaines questions d'entretien Java sur le multithreading.

Q19. Un fil de discussion peut-il être lancé deux fois ?

Réponse : Non, un fil de discussion ne peut pas être démarré deux fois. Si nous essayons de démarrer un fil de discussion deux fois, il lancera « java.lang.IllegalThreadStateException ».

Q20. Qu'est-ce qu'un hook d'arrêt en Java ?

Réponse : Ce sont les questions d'entretien Java les plus populaires sur le multithreading posées lors d'une interview. Un hook d'arrêt est un mécanisme utilisé pour nettoyer les ressources lorsque la JVM s'arrête normalement ou brusquement.

Q21. Qu'est-ce qui est volatile ?

Réponse : Volatile est un mot-clé en Java, et il peut être utilisé avec des variables. Si une variable est déclarée volatile, tous les threads liront la valeur de la même variable depuis la mémoire principale plutôt que depuis le cache ; ainsi, cela empêche les erreurs de lecture lorsque plusieurs threads utilisent la même variable dans leurs opérations.

Q22. Comment implémenter un thread en JAVA ?

Réponse : Java propose deux façons d'implémenter des threads dans un programme. L'interface java.Lang.Runnable possède une instance de la ligne Java.lang.A qui nécessite l'exécution d'une tâche via une instance. La classe Thread implémente déjà Runnable, donc un utilisateur peut directement remplacer la méthode run() en étendant la classe Thread ou en implémentant l'interface Runnable.

Q23. Quand utiliser Runnable et quand utiliser Thread en Java ?

Réponse : Java offre une meilleure implémentation de l'interface Runnable plutôt que d'étendre la classe Thread car Java n'autorise qu'un seul héritage. Étant donné qu'une classe peut implémenter plusieurs interfaces mais n'étendre qu'une seule classe, cela offre une plus grande flexibilité lorsqu'il s'agit de partager du code entre les classes.

Q24. Pourquoi dit-on que le comportement de Thread est imprévisible ?

Réponse : La raison en est le planificateur de threads qui gère l'exécution des threads. Le planificateur peut effectuer différentes performances sur les plateformes Windows, UNIX et LINUX. Lors de l'exécution, le même thread peut donner des sorties différentes sur différentes plates-formes, parfois même sur la même plate-forme. Pour résoudre ce problème, un utilisateur peut créer le même objet Runnable, créer des boucles run() dans les deux threads et démarrer les deux lignes ensemble.

Q25. What is a volatile variable in Java, and what is its significance?

Answer: Java facilitates users to share variables present in different threads. A volatile variable acts as a unique modifier that can be used only for instance variables. It provides that a write will happen before any consequent read. The Java memory model ensures the consistency of this variable.

Q26. What is the use of the synchronized keyword? What is the difference between synchronized and volatile keywords?

Answer: The synchronized keyword is used when the goal is to allow only one thread to run at a time in a specific section of code. It can be applied to define four different types of blocks, as shown below:

• Instance methods
• Static methods
• Code blocks inside instance methods
• Code blocks inside static methods

It can be declared as follows:

Public synchronized void example () {}

A volatile variable will never land up in a deadlock as it does not require obtaining any lock. While in synchronized variables, it may end up in a draw if they are not done correctly.

Q27. Why methods like wait(), notify(), and notify all() are present in the object class and not in the Thread class?

Answer: Object class has monitors that allow the Thread to lock an object, while Thread does not have any monitors. The object class’s monitor checks for the thing to see if it is available. Thread class having these methods would not help as multiple threads exist on an object, not vice versa.

Q28. Explain the difference between sleep() and wait() methods.

Answer:

• When the wait() method is called, the monitor moves the Thread from running to waiting for the state. Once a thread is in wait(), then it can move to runnable only when it has notified () or told all () for that object. The scheduler changes the state after this. While in the sleep() method, the state is changed to wait and will return to runnable only after sleep time.
• The wait () method is a part of Java.lang.Object class, while sleep() is a part of Java.lang.Thread class.

Q29. How to force start a thread in Java?

Answer: In Java, multithreading, one cannot force start a thread. Only thread schedulers can control lines and are not exposed to any API for control.

Q30. Does Thread leave object lock when wait() and sleep() methods are called?

Answer: A thread in the sleep() method does not leave the lock and moves to the waiting state. The Thread waits for sleep time to get over.

Q31. Explain the advantages of Multithreading.

Answer :
When it comes to software development, multithreading has several benefits:

1. Enhanced Performance: By utilizing multiple processor cores to execute tasks in parallel, multithreading improves the overall performance of applications.
2. Responsiveness: Multithreading helps applications with graphical user interfaces stay responsive by running background tasks simultaneously.
3. Resource Utilization: By allowing some threads to continue processing while others wait for I/O operations, efficient use of the system’s resources is achieved, maximizing the use of CPU and I/O devices.
4. Maintainability and modularity: Multithreading encourages modular design by assigning distinct threads to handle different functions, which results in code that is easier to read and maintain.
5. Asynchronous Programming: Multithreading makes it possible for tasks to run independently of the main program flow, which is essential for managing events or asynchronous input/output tasks.

Q32. How does time slicing differ from preemptive scheduling?

Answer:
1. Preemptive Scheduling: It is a scheduling technique used by operating systems that allows the system to start or stop a task that is presently underway in order to focus on a higher priority task.

Example: In a preemptive scheduling system, even if a lower-priority task is presently running, it may be preempted from execution if a higher-priority task becomes ready to run.

2. Round Robin Scheduling (Time Slicing): It is a scheduling technique where each process or thread is assigned a fixed time slot or quantum during which it can execute. Once the time slice expires, the next task in the queue is given CPU time.

For instance, if the time slice is set to 10 milliseconds and there are three tasks (A, B, and C), each task receives 10 milliseconds of CPU time in a cyclic fashion (A for 10 ms, then B for 10 ms, and so on).

Q33. What is deadlock?

Answer: Every thread in a system that is waiting for a resource that another waiting thread is holding causes a deadlock. In this case, all of the threads are in a universal waiting state because none of them can continue executing. A deadlock occurs when there is no opportunity for any thread to execute, leading to a halt. Complex circumstances known as deadlocks can impair a program’s regular runtime and possibly lead to coding problems. Maintaining the system’s performance and stability requires controlling and avoiding deadlocks.

Q34. How can a deadlock situation be identified? How is it easily avoidable?

Answer: Tools that display blocked threads, such as thread dumps, can be used to identify deadlocks. TryLock with timeouts, acquiring locks in a consistent order, and reducing lock contention are ways to prevent deadlocks. To lower the chance of deadlocks, properly design multithreaded programs and make use of higher-level concurrency tools.

Q35. Is there a stack for every thread in multithreaded programming?

Answer: Yes, every thread in multithreaded programming has a separate stack. Local variables and details about each thread’s function calls are kept on the stack. Each thread will function independently and have a dedicated area to manage its execution context because of this division.

Q36. How is a thread’s safety achieved?

Answer: A class is considered thread-safe when multiple threads can use its methods or objects concurrently without experiencing conflicts. In multithreaded programming, achieving thread safety is essential to avoiding race situations. This can be done in a few different ways:

• Synchronization: Limiting access to shared resources by employing locks and other mechanisms to make sure that only one thread at a time can access crucial areas.
• Volatile Keyword: Designating variables as volatile ensures consistency by making changes made to the variable by one thread visible to other threads.
• Lock-Based Mechanism: This technique uses explicit locks, like ReentrantLock, to control access to important code segments and stop thread interference.
• Atomic wrapper classes: (such as AtomicInteger and AtomicBoolean) for operations that must be carried out atomically without the need for explicit.

Q37. Tell me the difference between User thread and Daemon thread?

Answer: 

Characteristic	User Threads	Daemon Threads
Creation and Control	created and managed by the user or the application.	The application or user creates and controls these threads, but they can be explicitly set as daemon threads using the setDaemon(true) method.
JVM Termination Impact	JVM will wait for user threads to complete before exiting.	JVM can exit even if daemon threads are still running. Daemon threads are abruptly stopped if all user threads have finished their execution.
Example (Java)	java Thread userThread = new Thread(() -> { /* Thread logic */ }); userThread.start();	java Thread daemonThread = new Thread(() -> { /* Thread logic */ }); daemonThread.setDaemon(true); daemonThread.start();

Q38. How are daemon threads made?

Answer: The Thread class in Java provides the setDaemon(boolean on) method, which can be used to create daemon threads. When all non-daemon threads have finished running, a daemon thread operates in the background and does not stop the Java Virtual Machine (JVM) from shutting down.

Here’s an easy illustration:

public class DaemonThreadExample {
public static void main(String[] args) {
Thread daemonThread = new Thread(() -> {
while (true) {
// Do some background tasks
System.out.println("Daemon Thread is running");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
// Setting the thread as daemon
daemonThread.setDaemon(true);
// Starting the daemon thread
daemonThread.start();
// Main thread
System.out.println("Main thread is finished");
}
}

Output:

Explanation:

The daemonThread.setDaemon(true) line in this example designates the thread as a daemon thread. Regardless of its state, the daemon thread will end when the main thread completes its execution and the JVM terminates.

It is crucial to remember that a thread will throw an IllegalThreadStateException if it is not started as a daemon. You are unable to alter a thread’s daemon status once it has begun.

Q39. How do notify() and notifyAll() differ from one another?

Answer:
1. notify():

• Wakes up one of the threads that are currently waiting on the object.
• The scheduling policy of the JVM determines which thread will be notified, and this decision is not guaranteed.

2. notifyAll():

• Wakes up all the threads that are currently waiting on the object.
• Usually makes sure that every thread in line has an opportunity to obtain the lock and verify the altered state.

Q40. What does it mean to be in a deadlock and when can it happen?

Answer: Multiple processes create a deadlock in computing when they become stuck holding resources, waiting for another process to acquire that resource. This situation prevents any progress and results in mutual blocking between the processes.

When the following four requirements referred to as the Coffman conditions—are satisfied, a deadlock usually results:

• Mutual Exclusion: One or more resources must be kept in a non-sharable mode, which limits the resource’s use to a single process at a time.
• Hold and Wait: A process needs to be holding one resource at a time while it waits to obtain more resources that other processes are holding.
• No Preemption: Resources must be released willingly from a process; they cannot be taken away by force.
• Circular Wait: When two or more processes are in a circular chain, each process is waiting for a resource that the subsequent process in the chain is holding.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!