Vous trouverez ci-dessous des questions d'entrevue populaires liées aux fils Java, vous pouvez les utiliser pour vous préparer à l'entretien.
1) Qu'est-ce qu'un fil?
Un thread est la plus petite unité que le système d'exploitation peut effectuer des opérations et la planification. Il est contenu dans le processus et est l'unité de fonctionnement réelle du processus. Les programmeurs peuvent programmer des multiprocesseurs à travers lui, et vous pouvez accélérer les tâches à forte intensité de l'opération en utilisant le multithreading. Par exemple, s'il faut 100 millisecondes à un fil pour terminer une tâche, il ne faut que 10 millisecondes pour qu'un fil de discussion termine le changement de tâche à l'aide de dix threads. Java fournit un excellent support pour le multithreading au niveau de la langue, et c'est aussi un bon argument de vente. Pour plus de détails, veuillez cliquer ici.
2) Quelle est la différence entre un thread et un processus?
Les threads sont des sous-ensembles de processus. Un processus peut avoir de nombreux threads, et chaque thread effectue différentes tâches en parallèle. Différents processus utilisent différents espaces de mémoire, tandis que tous les threads partagent le même espace mémoire. Ne le gâchez pas avec la mémoire de pile, chaque thread a une mémoire de pile séparée pour stocker les données locales. Pour plus de détails, veuillez cliquer ici.
3) Comment implémenter des threads en Java?
Il y a deux façons au niveau de la langue. Une instance de la classe java.lang.thread est un thread, mais il doit appeler l'interface java.lang.runnable à exécuter. Étant donné que la classe de thread elle-même est l'interface Runnable appelée, vous pouvez hériter de la classe java.lang.thread ou appeler directement l'interface Runnable pour remplacer la méthode run () pour implémenter le thread. Pour plus de détails, veuillez cliquer ici.
4) Utiliser Runnable ou Thread?
Cette question est un suivi de la question précédente. Tout le monde sait que nous pouvons implémenter des threads en héritant de la classe de threads ou en appelant l'interface Runnable. La question est de savoir quelle méthode est la meilleure? Dans quelles circonstances dois-je l'utiliser? Cette question est facile à répondre si vous savez que Java ne prend pas en charge l'héritage multiple des classes, mais vous permet d'appeler plusieurs interfaces. Donc, si vous souhaitez hériter d'autres classes, bien sûr, il est préférable d'appeler l'interface Runnable. Pour plus de détails, veuillez cliquer ici.
6) Quelle est la différence entre les méthodes start () et run () dans la classe de threads?
Cette question est souvent posée, mais elle peut toujours distinguer la compréhension de l'intervieweur du modèle de filetage Java. La méthode start () est utilisée pour démarrer le thread nouvellement créé, et la méthode run () est appelée interne, ce qui est différent de l'effet d'appeler directement la méthode Run (). Lorsque vous appelez la méthode run (), elle ne sera appelée que dans le thread d'origine. Si aucun nouveau thread n'est démarré, la méthode start () démarrera le nouveau thread. Pour plus de discussions, veuillez cliquer ici
7) Quelle est la différence entre courir et appelable en Java?
Runnable et callable représentent des tâches à exécuter dans différents threads. Runnable est disponible depuis JDK1.0, et Callable a été ajouté dans JDK1.5. Leur principale différence est que la méthode Call () de Calsable peut renvoyer des valeurs et lancer des exceptions, tandis que la méthode Run () de Runnable n'a pas ces fonctions. Calable peut renvoyer un futur objet chargé des résultats de calcul. Mon blog a des instructions plus détaillées.
8) Quelle est la différence entre Cyclicbarrier et CountdownLatch en Java?
Cyclicbarrier et CountdownLatch peuvent être utilisés pour faire en sorte qu'un groupe de threads attend d'autres threads. Contrairement à CyclicBarrier, le compte à rebours ne peut pas être réutilisé. Cliquez ici pour voir plus d'informations et un exemple de code.
9) Quel est le modèle de mémoire Java?
Le modèle de mémoire Java spécifie et guide les programmes Java pour se comporter de manière déterministe entre différentes architectures de mémoire, CPU et systèmes d'exploitation. Il est particulièrement important dans les situations multiples. Le modèle de mémoire Java peut garantir que les modifications apportées par un thread sont visibles par d'autres threads et que les relations se produisent en premier. Cette relation définit certaines règles pour rendre les programmeurs plus clairs dans leur programmation simultanée. Par exemple, avoir une relation assure d'abord:
Le code dans les threads peut être exécuté en séquence, qui est appelé règles de commande de programme.
Pour le même verrouillage, une opération de déverrouillage doit se produire avant une autre opération de verrouillage qui se produit dans le temps, qui est également appelée règle de verrouillage de gestion.
L'opération d'écriture précédente à un volatile est avant l'opération de lecture suivante d'un volatil, qui est également appelé la règle de variable volatile.
Toute opération dans un thread doit être appelée après le début () de ce thread, également connu sous le nom de règle de démarrage du thread.
Toutes les opérations d'un thread seront terminées avant la fin du thread.
Le fonctionnement de terminaison d'un objet doit être après la construction de l'objet, qui est également appelé la règle de terminaison de l'objet.
Transitif
Je vous recommande fortement de lire le chapitre 16 de la «pratique de la programmation de la concurrence Java» pour approfondir votre compréhension du modèle de mémoire Java.
10) Quelle est la variable volatile en Java?
Volatile est un modificateur spécial qui ne peut être utilisé que par les variables membre. Dans le cas où les programmes simultanés Java manquent de classes synchrones, les opérations multithreading sur les variables membres sont transparentes à d'autres threads. La variable volatile peut garantir que l'opération de lecture suivante se produira après l'opération d'écriture précédente, qui est la règle de variable volatile de la question précédente. Cliquez ici pour voir plus de contenu lié au volatile.
11) Qu'est-ce que la sécurité des fils? Vector est-il une classe en file d'attente? (Voir ici pour plus de détails)
Si votre code est dans le processus où vous vous trouvez, il y a plusieurs threads s'exécute en même temps, et ces threads peuvent exécuter ce code en même temps. Si le résultat de chaque exécution est le même que le résultat d'une seule exécution de thread et que les valeurs des autres variables sont les mêmes que prévu, elle est en file. Le même objet d'instance d'une classe de comptoir en filetage ne provoquera pas des erreurs de calcul lorsqu'elle est utilisée par plusieurs threads. De toute évidence, vous pouvez diviser la classe de collection en deux groupes, en filetage et sans thread-safe. Vector utilise des méthodes de synchronisation pour obtenir la sécurité des threads, tandis que ArrayList similaire n'est pas un filetage.
12) Quelles sont les conditions de course à Java? Donner un exemple.
Les conditions de course entraîneront certains bugs dans des situations simultanées du programme. Lorsque le multi-threading concourt certaines ressources, des conditions de course surviendront. Si le premier programme à exécuter échoue et est exécuté plus tard, certains bogues incertains apparaîtront dans l'ensemble du programme. Ces bogues sont difficiles à détecter et à se reproduire en raison de la concurrence aléatoire entre les fils. Un exemple est un traitement désordonné, voir la réponse pour plus de détails.
13) Comment arrêter un fil à Java?
Java fournit une API riche mais ne fournit pas une API pour l'arrêt des fils. JDK 1.0 avait à l'origine certaines méthodes de contrôle comme stop (), suspendre () et repseme (), mais en raison des menaces potentielles de blocage, ils ont été dépréciés dans les versions JDK suivantes. Après cela, le concepteur de l'API Java n'a pas fourni de moyen compatible et filial pour arrêter un fil. Lorsque la méthode Run () ou Call () est exécutée, le thread se terminera automatiquement. Si vous souhaitez mettre fin à un thread manuellement, vous pouvez utiliser la variable booléenne volatile pour quitter la boucle de méthode run () ou annuler la tâche pour interrompre le thread. Cliquez ici pour afficher l'exemple de code.
14) Que se passe-t-il lorsqu'une exception se produit lorsqu'un fil est en cours d'exécution?
Il s'agit d'une question d'interview Java très délicate que j'ai rencontrée dans une interview. Autrement dit, si l'exception n'est pas capturée, le fil cessera d'exécuter.
Thread.UncaughtexceptionHandler est une interface intégrée pour gérer les exceptions non revues qui provoquent une interruption soudaine du fil. Lorsqu'une exception non revêtue provoque l'interruption d'un fil, le JVM utilisera thread.getUngaughtexceptionHandler () interroger le thread UngaughtexceptionHandler et passer le thread et l'exception en tant que paramètres à la méthode UngaughTexception () du gestionnaire pour le traitement.
15) Comment partager les données entre deux threads?
Vous pouvez le faire en partageant des objets ou en utilisant des structures de données simultanées comme le blocage des files d'attente. Ce tutoriel, "Java Inter-Thread Communication" (qui implique le partage d'objets entre deux threads) utilise les méthodes d'attente et de notification pour implémenter le modèle de consommateur producteur.
16) Quelle est la différence entre Notify et Notifyall en Java?
Il s'agit d'un autre problème délicat, car le multithreading peut attendre les verrous de surveillance uniques, et les concepteurs d'API Java fournissent des moyens de les informer lorsque vous attendez que les conditions changent, mais ces méthodes ne sont pas entièrement implémentées. La méthode notify () ne peut pas réveiller un thread spécifique, il ne fonctionnera donc que lorsqu'un thread attend. Et notifyall () réveille tous les threads et leur permet de rivaliser pour les verrous pour garantir qu'au moins un thread peut continuer à s'exécuter. Mon blog a des informations plus détaillées et un exemple de code.
17) Pourquoi les méthodes d'attente, notifier et notifiernt-elles ne sont-elles pas dans la classe de threads?
Il s'agit d'une question liée à la conception qui examine la perception de l'intervieweur des systèmes existants et quelque chose qui est courant mais qui semble déraisonnable. Lorsque vous répondez à ces questions, vous devez expliquer pourquoi il est logique de mettre ces méthodes dans la classe d'objets et pourquoi ne pas les mettre dans la classe de fil. Une raison évidente est que les verrous fournis par Java sont au niveau de l'objet plutôt qu'au niveau du thread, et chaque objet a une serrure, obtenue via des threads. Si le fil doit attendre des verrous, il est logique d'appeler la méthode Wait () dans l'objet. Si la méthode Wait () est définie dans la classe de threads, il ne sera pas évident qui verrouille le fil qui attend. Autrement dit, depuis attendre, notifier et notifier les opérations au niveau du verrouillage, elles sont définies dans la classe d'objets car la serrure appartient à l'objet. Vous pouvez également consulter cet article pour en savoir plus.
18) Qu'est-ce qu'une variable threadlocale?
ThreadLocal est une variable spéciale dans Java. Chaque thread a un threadlocal, ce qui signifie que chaque thread a sa propre variable indépendante, et les conditions de course sont complètement éliminées. C'est un excellent moyen d'obtenir un filetage pour créer des objets coûteux. Par exemple, vous pouvez utiliser ThreadLocal pour fabriquer un thread-safe SimpledateFormat car cette classe est coûteuse à créer et nécessite de créer une instance différente pour chaque appel, il ne vaut donc pas la peine de l'utiliser localement. Si vous fournissez à chaque fil une copie unique des variables, cela améliorera considérablement l'efficacité. Tout d'abord, le nombre d'objets coûteux créés est réduit par le multiplexage. Deuxièmement, vous obtenez la sécurité des fils sans utiliser de synchronisation ou d'invariance coûteuse. Un autre bon exemple de variables locales de thread est la classe ThreadLocalrandom, qui réduit le nombre d'objets aléatoires coûteux créés dans un environnement multi-thread. Voir les réponses pour en savoir plus.
19) Qu'est-ce que Futuretask?
Dans un programme concurrent Java, FutureTask représente une opération asynchrone qui peut être annulée. Il propose des méthodes telles que le démarrage et l'annulation des opérations, en interrogeant si les opérations sont terminées et en récupérant les résultats de l'opération. Le résultat ne peut être récupéré que lorsque l'opération est terminée. Si l'opération n'est pas terminée, la méthode GET bloquera. Un objet FutureTask peut envelopper des objets qui appellent appelable et runnable. Étant donné que FutureTask appelle également l'interface Runnable, il peut être soumis à l'exécuteur pour exécution.
20) Quelle est la différence entre les méthodes interrompues et ISinterruptedd en Java?
La principale différence entre interruption () et ISinterrupted () est que le premier effacera l'état d'interruption, alors que le second ne le fera pas. Le mécanisme d'interruption de Java Multithreading est implémenté avec des identifiants internes. L'appel thread.interrupt () pour interrompre un thread définira l'identifiant d'interruption sur true. Lorsque le thread d'interruption appelle la méthode statique thread.interrupted () pour vérifier l'état d'interruption, l'état d'interruption sera effacé. La méthode non statique est Interrupted () est utilisée pour interroger l'état d'interruption des autres threads sans modifier l'identifiant d'état d'interruption. En termes simples, toute méthode qui lance une interruption de l'interruption effacera l'état d'interruption. Dans tous les cas, l'état d'interruption d'un fil peut être modifié par d'autres threads appelant les interruptions.
21) Pourquoi les méthodes d'attente et de notification doivent-elles être appelées dans un bloc synchrone?
Cela est principalement dû au fait que l'API Java oblige cela, et si vous ne le faites pas, votre code lèvera une exception illégalitorstateException. Une autre raison est d'éviter les conditions de course entre attendre et notifier.
22) Pourquoi devriez-vous vérifier les conditions d'attente dans la boucle?
Les threads dans l'état d'attente peuvent recevoir des alertes d'erreur et des scénarios pseudo. Si la condition d'attente n'est pas vérifiée dans la boucle, le programme sortira sans remplir la condition finale. Par conséquent, lorsqu'un fil d'attente se réveille, il ne peut pas être considéré que son état d'attente d'origine est toujours valide, et il peut changer pendant cette période après l'appel de méthode Notify () et avant que le thread d'attente ne se réveille. C'est pourquoi l'utilisation de la méthode Wait () dans une boucle fonctionne mieux, vous pouvez créer des modèles dans Eclipse pour appeler Wait et notifier et l'essayer. Si vous voulez en savoir plus sur ce problème, je vous recommande de lire les chapitres de filetage et de synchronisation dans le livre "Effective Java".
23) Quelle est la différence entre les collections synchrones et les collections simultanées en Java?
Les collections synchrones et les collections simultanées fournissent des collections de filetage appropriées pour le multithreading et la concurrence, mais les collections simultanées sont plus évolutives. Avant Java 1.5, les programmeurs n'utilisaient que des collections synchrones, et lorsque la concurrence multi-thread contribuait, cela entraînerait une affirmation, entravant l'évolutivité du système. Java5 introduit des collections simultanées comme ConcurrentHashMap, qui non seulement assure la sécurité des fils mais améliore également l'évolutivité avec les technologies modernes telles que la séparation des serrures et les zones internes. Voir la réponse pour plus de détails.
24) Quelle est la différence entre le tas et la pile en Java?
Pourquoi cette question est-elle classée dans des questions d'interview multithread et simultanées? Parce que la pile est une zone de mémoire étroitement liée au fil. Chaque thread a sa propre mémoire de pile, qui est utilisée pour stocker des variables locales, des paramètres de méthode et des appels de pile. Les variables stockées dans un thread sont invisibles pour d'autres threads. Le tas est une zone de mémoire commune partagée par tous les threads. Les objets sont créés dans le tas. Afin d'améliorer l'efficacité, le fil mettra en cache A du tas à sa propre pile. Si plusieurs threads utilisent cette variable, cela peut causer des problèmes. À l'heure actuelle, la variable volatile peut jouer un rôle, ce qui nécessite que le thread lise la valeur de la variable de la mémoire principale.
Voir la réponse pour plus de détails.
25) Qu'est-ce qu'une piscine de fil? Pourquoi l'utiliser?
La création de threads prend des ressources et du temps coûteux. Si un thread n'est créé qu'après la tâche, le temps de réponse deviendra plus long et un processus peut créer un nombre limité de threads. Pour éviter ces problèmes, plusieurs threads sont créés pour répondre et traiter lorsque le programme est démarré. Ils sont appelés pools de threads et les fils à l'intérieur sont appelés threads de travailleur. À partir de JDK1.5, l'API Java fournit le cadre de l'exécuteur qui vous permet de créer différents pools de threads. Par exemple, un pool de fils unique, qui gère une tâche à la fois; Un nombre fixe de pools de threads ou de pools de filetages de cache (un pool de threads extensible adapté à de nombreux programmes avec des tâches de courte durée). Voir cet article pour plus de détails.
26) Comment écrire du code pour résoudre les problèmes du producteur et des consommateurs?
En réalité, bon nombre des problèmes de fil que vous résolvez appartiennent au modèle de consommation producteur, à savoir qu'une tâche de production de thread est destinée à la consommation par d'autres threads. Vous devez savoir comment communiquer entre les fils pour résoudre ce problème. La méthode de niveau relativement bas consiste à utiliser Wait and Notify pour résoudre ce problème. La méthode la plus excellente consiste à utiliser le sémaphore ou le blocage Blocking pour implémenter le modèle producteur et consommateur. Ce tutoriel l'implémente.
27) Comment éviter les blocages?
Blocage dans le multithreading java
L'impasse fait référence à un phénomène d'attente mutuelle causée par deux processus ou plus au cours du processus d'exécution en raison de la concurrence des ressources. Sans forces externes, ils ne pourront pas continuer. C'est un problème grave, car les impasses rendront votre programme suspendre et incapable de terminer la tâche. Les quatre conditions suivantes doivent être remplies pour la survenue de blocs impatients:
Condition d'exclusion mutuelle: une ressource ne peut être utilisée que par un seul processus à la fois.
Conditions de demande et de maintien: lorsqu'un processus bloque en raison de la demande de ressources, il conserve les ressources acquises.
Conditions pour ne pas priver: les ressources obtenues par le processus ne peuvent être privées de force que la fin d'utilisation.
Conditions d'attente de boucle: une relation de ressources en attente de boucle est formée entre plusieurs processus connectés dans la tête et la queue.
Le moyen le plus simple d'éviter les impasses est d'empêcher les conditions d'attente de boucle, de définir des drapeaux et de trier toutes les ressources du système, et de stipuler que toutes les ressources d'application de traitement doivent être exploitées dans un certain ordre (ordre croissant ou décroissant) pour éviter les impasses. Ce tutoriel a des exemples de code et des détails de discussion sur l'évitement des impasses.
28) Quelle est la différence entre les serrures en direct et les impasses en Java?
Ceci est l'extension de la question précédente. Les serrures en direct sont similaires aux impasses. La différence est que l'état du fil ou du processus dans le verrou vivant change constamment. Les serrures en direct peuvent être considérées comme une faim spéciale. Un exemple réaliste de verrouillage en direct est lorsque deux personnes se rencontrent dans un couloir étroit. Les deux essaient de s'éviter les uns les autres pour que les uns les autres puissent passer, mais parce que la direction d'évitement est la même, personne ne peut traverser le couloir à la fin. En termes simples, la principale différence entre une serrure en direct et une serrure morte est que l'état de l'ancien processus peut être modifié mais ne peut pas être exécuté.
29) Comment détecter si un fil a une serrure?
Je n'ai jamais su que nous pouvions réellement détecter si un fil avait une serrure avant d'avoir assisté à un entretien téléphonique. Il existe une méthode dans java.lang.thread appelé HoldSlock (), qui renvoie true si et seulement si le thread actuel possède un verrou pour un objet spécifique. Vous pouvez consulter cet article pour en savoir plus.
30) Comment obtenez-vous la pile de threads en Java?
Pour différents systèmes d'exploitation, il existe plusieurs façons d'obtenir la pile de threads des processus Java. Lorsque vous obtenez la pile de threads, le JVM stockera l'état de tous les threads dans le fichier journal ou le publiera sur la console. Dans Windows, vous pouvez utiliser la combinaison Ctrl + Break Key pour obtenir la pile de threads et utiliser la commande Kill -3 dans Linux. Vous pouvez également utiliser l'outil JSTACK pour l'obtenir, qui fonctionne sur les ID de thread, et vous pouvez utiliser l'outil JPS pour trouver l'ID.
31) Quel paramètre dans JVM est utilisé pour contrôler la pile de threads avec une petite pile
Ce problème est très simple, le paramètre -XSS est utilisé pour contrôler la taille de la pile du fil. Vous pouvez afficher la liste de configuration JVM pour plus d'informations sur ce paramètre.
32) Quelle est la différence entre synchronisé et reentrantlock en Java?
Java a pu obtenir une exclusion mutuelle depuis longtemps grâce à des mots clés synchronisés, et il a des inconvénients. Par exemple, vous ne pouvez pas étendre les méthodes ou bloquer les limites autres que les verrous, et vous ne pouvez pas annuler à mi-chemin lorsque vous essayez d'acquérir des verrous, etc. Java 5 fournit des contrôles plus complexes pour résoudre ces problèmes via l'interface de verrouillage. La classe ReentrantLock implémente le verrouillage, qui a la même concurrence et la même sémantique de mémoire que synchronisée et elle est également extensible. Vous pouvez consulter cet article pour en savoir plus
33) Il y a trois fils T1, T2 et T3. Comment s'assurer qu'ils sont exécutés dans l'ordre?
Il existe de nombreuses façons d'activer les threads à s'exécuter dans un ordre spécifique dans Multithreading. Vous pouvez utiliser la méthode join () de la classe de threads pour démarrer un autre thread dans un thread, et un autre thread complète le thread pour continuer à exécuter. Pour assurer l'ordre de trois fils, vous devez commencer le dernier (T3 appelle T2, T2 appelle T1), afin que T1 se termine en premier et T3 se terminera en dernier. Vous pouvez consulter cet article pour en savoir plus.
34) Quelle est la fonction de la méthode de rendement dans la classe de threads?
La méthode de rendement peut suspendre l'objet de thread en cours d'exécution et autoriser d'autres threads avec la même priorité à exécuter. Il s'agit d'une méthode statique et garantit seulement que le thread actuel abandonne l'utilisation du processeur et ne peut garantir que d'autres threads peuvent occuper le CPU. Le thread exécutant le rendement () peut être exécuté immédiatement après l'entrée dans l'état pause. Cliquez ici pour en savoir plus sur la méthode de rendement.
35) Quelle est la concurrence de la mêmehashmap concurrent en Java?
ConcurrenthashMap divise la carte réelle en plusieurs parties pour réaliser son évolutivité et sa sécurité en filetage. Cette division est obtenue en utilisant la concurrence, qui est un paramètre facultatif au constructeur de classe concurrenthashmap, avec une valeur par défaut de 16, de sorte que les affirmations peuvent être évitées dans des situations de lecture multithre. Pour plus de redimensionnement de la concurrence et du redimensionnement interne, veuillez lire mon article comment ConcurrenthashMap fonctionne en Java.
36) Qu'est-ce que le sémaphore en Java?
Le sémaphore dans Java est une nouvelle classe de synchronisation, qui est un signal de comptage. Conceptuellement, conceptuellement, le sémaphore maintient un ensemble de permis. Si nécessaire, chaque acquire () sera bloqué avant que la licence ne soit disponible avant d'être obtenue. Chaque version () ajoute une autorisation, qui peut libérer un acquéreur de blocage. Cependant, sans utiliser l'objet de licence réel, le sémaphore ne compte que les numéros de licence disponibles et prend des actions correspondantes. Les sémaphores sont souvent utilisés dans le code multithread, tels que les pools de connexion de base de données. Pour plus de détails, veuillez cliquer ici.
37) Si vous soumettez une tâche, la file d'attente du pool de threads est pleine. Que se passe-t-il lorsque cela se produit?
Cette question est astucieuse et de nombreux programmeurs penseront que la tâche bloquera jusqu'à ce que la file d'attente du pool de thread ait de l'espace. En fait, si une tâche ne peut être planifiée pour être exécutée, la méthode Soumide () du ThreadPoolExecutor lancera une exception RejectEdExecutionException.
38) Quelle est la différence entre les méthodes soumises () et EXECUTE () dans le pool de threads Java?
Les deux méthodes peuvent soumettre des tâches au pool de threads. Le type de retour de la méthode EXECUTE () est vide, qui est défini dans l'interface de l'exécuteur, et la méthode Soumide () peut renvoyer le futur objet tenant les résultats du calcul. Il est défini dans l'interface ExecutorService. Il étend l'interface de l'exécuteur. D'autres classes de pool de threads telles que ThreadPoolExecutor et ScheduledThreadPoolExecutor ont ces méthodes. Pour plus de détails, veuillez cliquer ici.
39) Qu'est-ce qu'une méthode de blocage?
Une méthode de blocage signifie que le programme attendra que la méthode se termine et ne fait rien d'autre. La méthode Accept () de Serversocket est d'attendre que le client se connecte. Le blocage ici signifie que le thread actuel sera suspendu avant le retour du résultat de l'appel et ne reviendra pas avant l'obtention du résultat. De plus, il existe des méthodes asynchrones et non bloquantes qui reviennent avant la fin de la tâche. Pour plus de détails, veuillez cliquer ici.
40) Swing Thread-Safe? Pourquoi?
Vous pouvez donner une réponse positive, le swing n'est pas un fil de fil, mais vous devez expliquer pourquoi cette réponse est même si l'intervieweur ne vous a pas demandé pourquoi. Lorsque nous disons que le swing n'est pas un filetage, il mentionne souvent ses composants, qui ne peuvent pas être modifiés en multiples. Toutes les mises à jour des composants de l'interface graphique doivent être terminées dans des threads AWT. Swing fournit deux méthodes de rappel synchrones et asynchrones à mettre à jour. Cliquez ici pour voir plus de contenu lié à la sécurité et à la sécurité des fils.
41) Quelle est la différence entre invokeandwait et invokelater à Java?
Ces deux méthodes sont fournies par l'API Swing aux développeurs Java pour mettre à jour les composants GUI du thread actuel plutôt que le thread de répartition des événements. Invokeandwait () met à jour de manière synchrone les composants de l'interface graphique, comme une barre de progression. Une fois les progrès mis à jour, la barre de progression doit également être modifiée en conséquence. Si la progression est suivie par plusieurs threads, la méthode invokeandWait () est appelée pour demander le thread de répartition des événements pour mettre à jour le composant en conséquence. La méthode invokelater () est appelée asynchrone pour mettre à jour le composant. Pour plus de détails, veuillez cliquer ici.
42) Quelles méthodes de l'API swing sont-elles-selles?
Cette question mentionne également le swing et la sécurité des filetages. Bien que les composants ne soient pas en file d'attente, certaines méthodes peuvent être appelées multi-threadable, telles que Repaind () et Revalidate (). La méthode setText () de JTextComponent et les méthodes insert () et annex () de JTextArea sont également filées.
43) Comment créer un objet immuable en Java?
Ce problème semble n'avoir rien à voir avec le multi-lancement, mais l'invariance aide à simplifier des programmes simultanés déjà complexes. Les objets immuables peuvent être partagés sans synchronisation, en réduisant la surcharge de synchronisation lors de l'accès simultané à l'objet. Cependant, Java n'a pas l'annotation @imutable. Pour créer une classe immuable, nous devons mettre en œuvre les étapes suivantes: Initialisez tous les membres via un constructeur, ne fournissez pas de méthode de setter à la variable et déclarez tous les membres en tant que privé, afin que ces membres ne soient pas autorisés à accéder directement. Dans la méthode Getter, ne renvoyez pas directement l'objet lui-même, mais clonez l'objet et renvoyez une copie de l'objet. Mon article Comment rendre un objet immuable dans Java a des tutoriels détaillés, et vous pouvez être plein de confiance après l'avoir lu.
44) Qu'est-ce que ReadWritelock en Java?
De manière générale, les serrures de lecture et d'écriture sont le résultat de la technologie de séparation des serrures utilisée pour améliorer les performances des programmes simultanés. ReadWriteLock in Java est une nouvelle interface ajoutée dans Java 5. Une lecture-writeLock maintient une paire de serrures associées, une pour les opérations en lecture seule et une pour les écritures. Un verrouillage de lecture peut être maintenu par plusieurs threads de lecture en même temps sans fil d'écriture. Les verrous d'écriture sont exclusifs, vous pouvez implémenter cette règle à l'aide de ReentRanTreadWriteLock dans JDK, qui prend en charge jusqu'à 65535 verrous d'écriture et 65535 verrous.
45) Qu'est-ce qu'une boucle occupée dans le multithreading?
Les boucles occupées sont lorsque les programmeurs utilisent des boucles pour faire attendre un fil. Contrairement aux méthodes traditionnelles telles que attendre (), sleep () ou rendement (), elles abandonnent toutes le contrôle du processeur, tandis que les boucles occupées n'abandonnent pas le processeur, il fait simplement une boucle vide. Le but de cela est de préserver le cache CPU. Dans un système multi-core, l'une attendant qu'un fil se réveille peut s'exécuter dans un autre noyau, qui reconstruira le cache. Il est disponible pour éviter de reconstruire le cache et de réduire le temps en attendant la reconstruction. Vous pouvez consulter cet article pour plus d'informations.
46) Quelle est la différence entre les variables volatiles et les variables atomiques?
C'est une question intéressante. Premièrement, la variable volatile ressemble beaucoup à la variable atomique, mais les fonctions sont différentes. La variable volatile garantit une relation prédécesseur, c'est-à-dire que les opérations d'écriture se produiront avant les opérations de lecture ultérieures, mais elle ne garantit pas l'atomicité. Par exemple, la modification de la variable de comptage avec volatile, alors l'opération Count ++ n'est pas atomique. La méthode atomique fournie par la classe atomicInteger peut rendre cette opération atomique. Par exemple, la méthode getandincrement () effectuera des opérations d'incrément atomique pour ajouter la valeur actuelle par un, et d'autres types de données et variables de référence peuvent également effectuer des opérations similaires.
47) Que se passe-t-il si un thread dans un bloc de synchronisation lance une exception?
Cette question a trompé de nombreux programmeurs Java. Si vous pouvez penser si le verrou libère cet indice pour répondre, vous espérez toujours y répondre correctement. Peu importe si votre bloc de synchronisation sort normalement ou anormalement, les threads à l'intérieur libéreront le verrou, donc je préfère le bloc de synchronisation par rapport à l'interface de verrouillage car il ne vous oblige pas à dépenser mon énergie pour libérer le verrou. Cette fonction peut être implémentée en libérant le verrouillage du bloc final.
48) Quel est le verrouillage de double vérification en mode singleton?
Cette question est souvent posée dans les entretiens de Java, mais l'intervieweur n'est que à 50% satisfait de répondre à cette question. La moitié des gens ne peuvent pas écrire un serrure à double contrôle et la moitié des gens ne peuvent pas dire que ce sont des dangers cachés et comment Java 1.5 l'a corrigé. Il s'agit en fait d'une ancienne méthode pour créer des singletons en filetage. Lorsqu'une instance singleton est créée pour la première fois, il essaie d'optimiser les performances avec un seul verrou, mais parce qu'il est trop complexe, il échoue dans JDK1.4, et que personnellement je ne l'aime pas non plus. Quoi qu'il en soit, même si vous ne l'aimez pas, vous devez toujours le comprendre car il est souvent demandé. Vous pouvez consulter comment le verrouillage à double vérification sur l'article Singleton Works pour plus d'informations.
49) Comment créer un singleton en filetage en Java?
Ceci est un suivi de la question ci-dessus. Si vous n'aimez pas les verrous à double vérification et que l'intervieweur a posé des questions sur une méthode alternative pour créer une classe singleton, vous pouvez utiliser la classe JVM Chargage et les fonctionnalités d'initialisation de variables statiques pour créer une instance singleton, ou utiliser des types d'énumération pour créer un singleton. J'aime cette méthode. Vous pouvez consulter cet article pour plus d'informations.
50) Écrivez 3 meilleures pratiques multithreading que vous suivez
J'aime le plus ce genre de problème, et je crois que vous suivrez certaines meilleures pratiques lorsque vous rédigerez du code simultané pour améliorer les performances. Voici trois meilleures pratiques que je pense que la plupart des programmeurs Java devraient suivre:
Donnez à votre fil un nom significatif.
Cela facilite la recherche de bugs ou de les suivre. OrderProcessor, Quteprocesseur ou TradeProcesseur Ce nom est bien meilleur que Thread-1. Thread-2 et Thread-3. Donnez au fil un nom lié à la tâche qu'il souhaite accomplir. Tous les principaux cadres et même JDK suivent cette meilleure pratique.
Évitez de verrouiller et de rétrécir la portée de la synchronisation
Les serrures sont coûteuses et le changement de contexte prend plus de temps. Essayez d'utiliser la synchronisation et les verrous pour minimiser la zone critique. Je préfère donc les blocs de synchronisation à la méthode de synchronisation, ce qui me donne un contrôle absolu sur le verrou.
Utilisez plus de classes de synchronisation et utilisez moins d'attente et de notification
Tout d'abord, CountdownLatch, Semaphore, Cyclicbarrier et les classes synchrones d'échangeur simplifient les opérations de codage, tandis qu'il est difficile de contrôler les flux de contrôle complexes avec attente et notification. Deuxièmement, ces classes sont écrites et maintenues par les meilleures entreprises. Ils continueront d'être optimisés et améliorés dans les JDK ultérieurs. En utilisant ces outils de synchronisation de niveau supérieur, votre programme peut être optimisé sans aucun effort.
Utilisez des ensembles plus concurrents et des ensembles moins synchronisés. Il s'agit d'une autre meilleure pratique facile à suivre. Les ensembles simultanés sont plus évolutifs que les ensembles synchronisés, donc utiliser des ensembles simultanés est meilleur pour la programmation simultanée. Si vous avez besoin d'utiliser MAP la prochaine fois, vous devriez d'abord penser à utiliser ConcurrentHashMap. Mon article des collections concurrentes Java a une description plus détaillée.
51) Comment forcer le démarrage d'un fil?
Ce problème est comme la façon de forcer la collection Java Garbage. Il n'y a pas encore de moyen de le faire. Bien que vous puissiez utiliser System.gc () pour effectuer la collecte des ordures, il n'est pas garanti de réussir. Il n'y a aucun moyen de forcer un fil à démarrer en Java, il est contrôlé par le planificateur de threads et Java ne publie pas l'API pertinente.
52) Qu'est-ce que le cadre de jointure de la fourche en Java?
fork join 框架是JDK7 中出现的一款高效的工具，Java 开发人员可以通过它充分利用现代服务器上的多处理器。它是专门为了那些可以递归划分成许多子模块设计的，目的是将所有可用的处理能力用来提升程序的性能。fork join 框架一个巨大的优势是它使用了工作窃取算法，可以完成更多任务的工作线程可以从其它线程中窃取任务来执行。你可以查看这篇文章获得更多信息。
53） Java 多线程中调用wait () 和sleep ()方法有什么不同？
Java 程序中wait 和sleep 都会造成某种形式的暂停，它们可以满足不同的需要。wait ()方法用于线程间通信，如果等待条件为真且其它线程被唤醒时它会释放锁，而sleep ()方法仅仅释放CPU 资源或者让当前线程停止执行一段时间，但不会释放锁。你可以查看这篇文章获得更多信息。