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.
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 :
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.
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.
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.
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.
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.
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.
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.
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.
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.
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. |
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.
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.
Réponse :
Les threads en Java peuvent être créés de deux manières :
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();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();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 :
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.
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.
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.
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 ».
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.
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.
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.
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.
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.
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.
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:
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.
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.
Answer:
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.
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.
Answer :
When it comes to software development, multithreading has several benefits:
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).
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.
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.
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.
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:
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();Copier après la connexion |
java Thread daemonThread =
new Thread(() -> {
/* Thread logic */
});
daemonThread.setDaemon(true);
daemonThread.start();Copier après la connexion |
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.
Answer:
1. notify():
2. notifyAll():
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:
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
