Questions d'entrevue multithread Java

Qu'est-ce qu'un fil de discussion ?

Le thread est la plus petite unité que le système d'exploitation peut effectuer la planification des opérations. Il est inclus dans le processus et constitue l'unité opérationnelle réelle du processus. Les programmeurs peuvent l'utiliser pour la programmation multiprocesseur, et vous pouvez utiliser le multithreading pour accélérer les tâches gourmandes en calcul. (Étude recommandée : questions d'entretien Java)

Par exemple, s'il faut 100 millisecondes à un thread pour terminer une tâche, alors il ne faut que 10 millisecondes pour utiliser dix threads pour terminer la tâche .

Quelle est la différence entre un thread et un processus ?

Les threads sont un sous-ensemble de processus. Un processus peut avoir plusieurs threads, et chaque thread effectue différentes tâches en parallèle. Différents processus utilisent différents espaces mémoire et tous les threads partagent le même espace mémoire. Chaque thread dispose d'une mémoire de pile distincte pour stocker les données locales.

Comment implémenter les threads en Java ?

Deux manières : une instance de la classe java.lang.Thread est un thread mais elle doit appeler l'interface java.lang.Runnable pour s'exécuter puisque la classe thread elle-même est l'interface Runnable appelée. , vous pouvez en hériter de la classe java.lang.Thread ou appeler directement l'interface Runnable pour remplacer la méthode run() pour implémenter les threads.

Quelles sont les fonctions et les différences entre les mots-clés Java volatiles et synchronisés ?

1, volatile

La variable qu'elle modifie n'en conserve pas de copie et accède directement à la mémoire principale.

Dans le modèle de mémoire Java, il y a la mémoire principale et chaque thread possède également sa propre mémoire (comme les registres). Pour des raisons de performances, un thread conserve une copie des variables auxquelles il accède dans sa propre mémoire.

De cette façon, la valeur de la même variable dans la mémoire d'un thread peut être incohérente avec la valeur dans la mémoire d'un autre thread ou avec la valeur dans la mémoire principale à un certain moment.

Déclarer une variable comme volatile signifie que la variable sera modifiée par d'autres threads à tout moment, elle ne peut donc pas être mise en cache dans la mémoire du thread.

2, synchronisé

Lorsqu'il est utilisé pour modifier une méthode ou un bloc de code, il peut garantir qu'au plus un thread exécute le code en même temps.

1. Lorsque deux threads simultanés accèdent au bloc de code de synchronisation synchronisé (ce) dans le même objet, un seul thread peut être exécuté à la fois. Un autre thread doit attendre que le thread actuel ait fini d'exécuter ce bloc de code avant de pouvoir exécuter ce bloc de code.

2. Cependant, lorsqu'un thread accède à un bloc de code synchronisé (this) d'un objet, un autre thread peut toujours accéder au bloc de code synchronisé non synchronisé (this) dans l'objet.

3. Ce qui est particulièrement critique est que lorsqu'un thread accède à un bloc de code synchronisé (this) d'un objet, les autres threads ne pourront pas accéder à tous les autres blocs de code synchronisés (this) dans l'objet.

4. Lorsqu'un thread accède à un bloc de code de synchronisation synchronisé (ceci) d'un objet, il obtient le verrou d'objet de cet objet. En conséquence, l'accès des autres threads à toutes les parties de code synchronisées de l'objet objet est temporairement bloqué.

5. Les règles ci-dessus s'appliquent également aux autres verrous d'objets

Quels sont les différents cycles de vie des threads ?

Lorsque nous créons un nouveau thread dans un programme Java, son statut est Nouveau. Lorsque nous appelons la méthode start() du thread, le statut passe à Runnable. Le planificateur de threads alloue du temps CPU aux threads du pool de threads exécutables et change leur statut en En cours d'exécution. Les autres états de thread incluent En attente, Bloqué et Mort.

Quelle est votre compréhension de la priorité des threads ?

Chaque thread a une priorité. De manière générale, les threads hautement prioritaires auront la priorité lors de l'exécution, mais cela dépend de la mise en œuvre de la planification des threads. Cette implémentation dépend du système d'exploitation.

Nous pouvons définir la priorité des threads, mais cela ne garantit pas que les threads de haute priorité s'exécuteront avant les threads de faible priorité. La priorité du thread est une variable int (de 1 à 10), 1 représente la priorité la plus basse, 10 représente la priorité la plus élevée.

Qu'est-ce qu'une impasse ? Comment analyser et éviter les impasses ?

Le blocage fait référence à une situation dans laquelle plus de deux threads sont bloqués pour toujours. Cette situation nécessite au moins deux threads supplémentaires et plus de deux ressources.

Pour analyser le blocage, nous devons examiner le thread dump de l'application Java. Nous devons découvrir quels threads sont à l'état BLOQUÉ et quelles ressources ils attendent. Chaque ressource a un identifiant unique, en utilisant cet identifiant, nous pouvons découvrir quels threads possèdent déjà son verrou d'objet.

Éviter les verrous imbriqués, utiliser les verrous uniquement lorsque cela est nécessaire et éviter l'attente indéfinie sont des moyens courants d'éviter les blocages.

Qu'est-ce que la sécurité des threads ? Vector est-il une classe thread-safe ?

S'il y a plusieurs threads exécutés en même temps dans le processus où se trouve votre code, ces threads peuvent exécuter ce code en même temps. Si les résultats de chaque exécution sont les mêmes que ceux des exécutions monothread et que les valeurs des autres variables sont les mêmes que celles attendues, cela est thread-safe.

Une classe de compteur thread-safe ne provoquera pas d'erreurs de calcul lorsque le même objet d'instance est utilisé par plusieurs threads. Évidemment, vous pouvez diviser les classes de collection en deux groupes, thread-safe et non-thread-safe. Vector utilise des méthodes synchronisées pour assurer la sécurité des threads, tandis qu'ArrayList, qui lui est similaire, n'est pas thread-safe.

Comment arrêter un thread en Java ?

Java fournit une API riche mais ne fournit pas d'API pour arrêter les threads. Le JDK 1.0 disposait à l'origine de certaines méthodes de contrôle telles que stop(), suspend() et Ensure(), mais elles ont été obsolètes dans les versions ultérieures du JDK en raison de menaces potentielles de blocage. Après cela, les concepteurs de l'API Java n'ont pas fourni de compatibilité et de thread-. moyen sûr d'arrêter un fil de discussion.

Le thread se terminera automatiquement lorsque la méthode run() ou call() est exécutée. Si vous souhaitez terminer manuellement un thread, vous pouvez utiliser la variable booléenne volatile pour quitter la boucle de la méthode run() ou annuler. la tâche. Interrompre le thread

Qu'est-ce que ThreadLocal ?

ThreadLocal est utilisé pour créer des variables locales du thread Nous savons que tous les threads d'un objet partageront son global. variables, donc ces variables ne sont pas thread-safe, nous pouvons utiliser des techniques de synchronisation. Mais lorsque nous ne voulons pas utiliser la synchronisation, nous pouvons choisir des variables ThreadLocal.

Chaque thread aura ses propres variables de thread, et ils pourront utiliser la méthode get()set() pour obtenir leurs valeurs par défaut ou modifier leurs valeurs dans le thread. Les instances ThreadLocal souhaitent généralement que leur état de thread associé soit des propriétés statiques privées.

Quelles sont les différences entre Sleep(), suspend() et wait() ?

Thread.sleep() met le thread actuel dans l'état "Non exécutable" à l'heure spécifiée. Le thread contient toujours le moniteur de l'objet. Par exemple, si un thread se trouve actuellement dans un bloc ou une méthode synchronisée, les autres threads ne peuvent pas entrer dans le bloc ou la méthode. Si un autre thread appelle la méthode interruption(), il réveillera le thread "en veille".

Remarque : sleep() est une méthode statique. Cela signifie qu'il n'est valable que pour le thread actuel. Une erreur courante consiste à appeler t.sleep(), (où t est un thread différent du thread actuel).

Même si t.sleep() est exécuté, le thread actuel se met en veille, pas le thread t. t.suspend() est une méthode obsolète. L'utilisation de suspend() entraînera la stagnation du thread. Le thread conservera toujours le moniteur de l'objet Suspend() peut facilement provoquer des problèmes de blocage.

object.wait() met le thread actuel dans un état "non exécutable". La différence avec sleep() est que wait est une méthode d'objet plutôt qu'un thread. Lors de l'appel de object.wait(), le thread doit d'abord acquérir le verrou d'objet de cet objet. Le thread actuel doit maintenir la synchronisation sur l'objet verrouillé et ajouter le thread actuel à la file d'attente.

Par la suite, un autre thread peut synchroniser le même verrou d'objet pour appeler object.notify(), ce qui réveillera le thread en attente d'origine puis libérera le verrou. Fondamentalement, wait()/notify() est similaire à sleep()/interrupt(), sauf que le premier doit acquérir le verrou d'objet.

Qu'est-ce que la famine de threads et qu'est-ce que le livelock ?

Lorsque tous les threads sont bloqués ou ne peuvent pas être traités car les ressources requises ne sont pas valides, il n'y a pas de threads non bloquants pour rendre les ressources disponibles. Le verrouillage dynamique des threads dans l'API Java peut se produire dans les situations suivantes :

1, lorsque tous les threads exécutent Object.wait(0) dans le programme et la méthode d'attente avec le paramètre 0. Le programme sera verrouillé jusqu'à ce qu'un thread appelle Object.notify() ou Object.notifyAll() sur l'objet correspondant.

2, quand tous les fils sont coincés dans une boucle infinie.

Qu'est-ce que la classe Java Timer ? Comment créer une tâche avec un intervalle de temps précis ?

java.util.Timer est une classe d'outils qui peut être utilisée pour planifier l'exécution d'un thread à un moment précis dans le futur. La classe Timer peut être utilisée pour planifier des tâches ponctuelles ou des tâches périodiques.

java.util.TimerTask est une classe abstraite qui implémente l'interface Runnable. Nous devons hériter de cette classe pour créer nos propres tâches planifiées et utiliser Timer pour planifier son exécution.

Quelle est la différence entre les collections synchronisées et les collections simultanées en Java ?

Les collections synchronisées et les collections simultanées fournissent des collections thread-safe appropriées pour le multithread et la concurrence, mais les collections simultanées sont plus évolutives.

Avant Java 1.5, les programmeurs ne pouvaient utiliser que des collections synchronisées, ce qui provoquait des conflits lorsque plusieurs threads s'exécutaient simultanément, entravant l'évolutivité du système.

Java5 a introduit des collections simultanées comme ConcurrentHashMap, qui assurent non seulement la sécurité des threads, mais améliorent également l'évolutivité grâce aux technologies modernes telles que la séparation des verrous et le partitionnement interne.

Méthode synchronisée ou bloc synchronisé, lequel est le meilleur choix ?

Un bloc synchronisé est un meilleur choix car il ne verrouille pas l'intégralité de l'objet (bien sûr vous pouvez également lui faire verrouiller l'intégralité de l'objet). Les méthodes synchronisées verrouillent l'intégralité de l'objet, même s'il existe plusieurs blocs synchronisés non liés dans la classe, ce qui entraîne généralement l'arrêt de leur exécution et la nécessité d'attendre pour acquérir le verrou sur l'objet.

Qu'est-ce qu'un pool de threads ? Pourquoi l'utiliser ?

La création de threads coûte cher en ressources et en temps. Si les threads sont créés uniquement lorsqu'une tâche arrive, le temps de réponse deviendra plus long et le nombre de threads pouvant être créés par un processus est limité.

Afin d'éviter ces problèmes, plusieurs threads sont créés pour répondre au traitement au démarrage du programme. Ils sont appelés pools de threads, et les threads à l'intérieur sont appelés threads de travail.

À partir de JDK1.5, l'API Java fournit le framework Executor afin que vous puissiez créer différents pools de threads. Par exemple, un seul pool de threads traite une tâche à la fois ; un nombre fixe de pools de threads ou un pool de threads de cache (un pool de threads évolutif adapté aux programmes comportant de nombreuses tâches de courte durée).

Quelle est la différence entre InvoquerAndWait et InvoquerLater en Java ?

Ces deux méthodes sont fournies par l'API Swing aux développeurs Java pour mettre à jour les composants de l'interface graphique à partir du thread actuel au lieu du thread de répartition d'événements. InvokeAndWait() met à jour de manière synchrone les composants de l'interface graphique, tels qu'une barre de progression. Une fois la progression mise à jour, la barre de progression doit également changer en conséquence.

Si la progression est suivie par plusieurs threads, appelez la méthode EnsureAndWait() pour demander au thread de répartition d'événements de mettre à jour le composant en conséquence. La méthode InvoqueLater() appelle le composant de mise à jour de manière asynchrone.

Qu'est-ce qu'une boucle occupée en multi-threading ?

Une boucle occupée se produit lorsque les programmeurs utilisent une boucle pour faire attendre un thread, contrairement à la méthode traditionnelle wait(), sleep() ou rendement() abandonnent tous deux le contrôle du CPU, mais la boucle occupée n'abandonne pas le CPU, elle exécute une boucle vide. Le but est de préserver le cache du processeur.

Sur un système multicœur, un thread en attente peut s'exécuter sur un autre cœur à son réveil, ce qui reconstruira le cache. Il peut être utilisé afin d'éviter de reconstruire le cache et de réduire le temps d'attente pour la reconstruction.

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!