Différence clé - sommeil vs attente en Java
Sleep and wait sont deux méthodes utilisées pour le multithreading en Java. La méthode sleep appartient à la classe Thread tandis que la méthode wait appartient à la classe Object. La principale différence entre sleep et wait en Java est que, le sleep est utilisé pour suspendre l'exécution du thread en cours pendant le nombre de millisecondes spécifié tandis que la méthode wait est utilisée pour faire attendre le thread actuel jusqu'à ce qu'un autre thread appelle la notification ou notifyAll pour l'objet.
Un thread est la plus petite unité de traitement du système d'exploitation. Il s'agit d'un flux séquentiel unique de contrôle au sein d'un programme. Les fils sont légers. Le multithreading est le mécanisme d'exécution de plusieurs threads en même temps. Les langages de programmation tels que Java prennent en charge le multithreading. Le multithreading présente des avantages car il permet d'exécuter plusieurs threads simultanément et les threads sont indépendants les uns des autres. Il existe des méthodes en Java qui peuvent être utilisées pour le multithreading. Deux d'entre eux dorment et attendent.
CONTENU
1. Présentation et différence clé
2. Qu'est-ce que le sommeil en Java
3. Qu'est-ce que l'attente en Java
4. Similitudes entre le sommeil et l'attente en Java
5. Comparaison côte à côte - sommeil vs attente en Java sous forme tabulaire
6. Résumé
Qu'est-ce que le sommeil en Java?
Il existe plusieurs processus en cours d'exécution dans un système d'exploitation. Un processus est un programme en cours d'exécution. Chaque processus peut avoir plusieurs threads et un changement de contexte se produit entre ces threads. En Java, il existe deux façons de créer un thread. C'est en étendant la classe de thread ou en implémentant l'interface Runnable. La classe Thread a des constructeurs et des méthodes pour créer et effectuer des opérations sur un thread. La classe Thread étend la classe Object et implémente l'interface Runnable. L'interface Runnable doit être implémentée par toute classe dont les instances sont destinées à être exécutées par un thread. Lorsque le thread s'exécute, le code qui doit s'exécuter est écrit dans la méthode run. Le thread qui doit s'exécuter est sélectionné par le planificateur de thread. Un seul thread s'exécute dans un seul processus.
Un fil passe par plusieurs phases. Après avoir créé un objet de la classe Thread, le programmeur peut appeler la méthode start. Avant d'appeler cette méthode, on dit que le thread est dans le nouvel état. Le planificateur de threads sélectionne un thread à exécuter. Si le thread n'est pas encore sélectionné par le planificateur de threads mais si la méthode de démarrage est appelée, alors le thread est dans un état exécutable. Une fois que le planificateur de thread a sélectionné le thread à exécuter, il passe à l'état en cours d'exécution. Si le thread est actif mais n'est pas actuellement éligible pour s'exécuter, il est alors dans un état non exécutable ou bloqué. Une fois la méthode d'exécution terminée, le thread passe à l'état terminé. Ce sont les principales phases du cycle de vie des threads.
Il existe différentes méthodes disponibles dans la classe de thread pour effectuer différentes tâches. La méthode de veille est utilisée pour mettre la méthode en veille pendant une durée spécifique. La syntaxe de la méthode sleep est la suivante: public void sleep (longues millisecondes) jette une exception InterruptedException. Cela provoque l'arrêt temporaire de l'exécution par le thread en cours d'exécution pendant un nombre spécifié de millisecondes. Si un autre thread interrompt le thread actuel, l'état d'interruption du thread actuel est effacé lorsque cette exception est levée.
Figure 01: Programme Java avec méthode de veille
Selon le programme ci-dessus, la méthode run contient du code qui doit être exécuté. Dans le programme principal, deux objets de ExampleThread1 sont créés et les méthodes de démarrage sont appelées sur eux. Cela permettra d'exécuter le code à l'intérieur de la méthode run. Un seul thread s'exécute à la fois. Avec le fil. sommeil (1000); permettra au premier thread de terminer l'exécution pendant 1000 millisecondes. Lorsqu'un thread est en veille, le planificateur de thread récupère l'autre thread.
Qu'est-ce que l'attente en Java?
Plusieurs threads peuvent accéder à une ressource partagée. Cela peut entraîner la génération d'une sortie incorrecte. La synchronisation des threads peut être utilisée pour créer un seul thread pour accéder à la ressource partagée. Supposons une situation comme suit. Si, il existe deux threads comme t1 et t2, t1 commence à enregistrer les valeurs dans un fichier texte appelé Text1.txt. Ces valeurs seront utilisées pour un autre calcul lorsque t1 revient. Si t2 commence avant le retour de t1, t2 peut changer les valeurs sauvegardées par t1. Cela peut amener t1 à fournir une sortie erronée. Avec l'aide de la synchronisation, lorsque t1 commence à utiliser le fichier Text1.txt, ce fichier peut être verrouillé, il n'est donc accessible que par t1. Le t2 ne peut pas le changer jusqu'à ce que t1 libère le verrou pour accéder à ce fichier texte. Lorsque la tâche est terminée, le t1 peut libérer le verrou. Le verrou est également connu sous le nom de moniteur.
La synchronisation des threads peut être réalisée par communication inter-thread. Une section critique est un segment de code qui accède aux ressources partagées. Dans la communication inter-thread, un thread est mis en pause dans sa section critique et un autre thread est autorisé à entrer dans la même section critique pour être exécuté. Il est implémenté en utilisant les méthodes wait, notify et notifyAll. Ils appartiennent à la classe Object. La méthode wait est utilisée pour permettre au thread actuel de libérer le verrou et d'attendre qu'un autre thread appelle la méthode notify ou notifyAll pour l'objet. La méthode de notification est utilisée pour réveiller un seul thread qui attend le verrou. Le notifyAll réveille tous les threads qui attendent le verrou.
Figure 02: Classe de calculatrice
Figure 03: Méthode principale
La classe Calculator étend le Thread. Le bloc synchronisé se trouve dans la méthode d'exécution. La boucle for et la méthode de notification se trouvent à l'intérieur du bloc synchronisé. Dans la méthode main, une instance d'un thread créé et la méthode de démarrage est appelée sur cette instance. La méthode principale attendra que le thread donne une notification. Lors de l'exécution du programme, la méthode main attend l'exécution complète de la méthode run et attend la méthode de notification. Une fois la méthode de notification appelée, la méthode principale cesse d'attendre et commence à exécuter le reste du code. Main attend que le thread de calculatrice soit terminé. Enfin, le résultat de la somme est imprimé.
S'il n'y a pas de bloc synchronisé et si la méthode principale a un code comme ci-dessous, elle donnera la sortie à zéro car elle n'attend pas que l'autre thread se termine.
Calculatrice t1 = nouvelle calculatrice ();
t1. début ();
System.out.println (t1.sum);
Quelle est la similitude entre dormir et attendre en Java?
Sleep et Wait sont des méthodes qui peuvent être utilisées lors de l'implémentation du multithreading en Java
Quelle est la différence entre dormir et attendre en Java?
Diff article au milieu avant la table
dormir vs attendre en Java |
|
| La méthode sleep entraîne la suspension de l'exécution par le thread actuel pendant le nombre de millisecondes spécifié, sous réserve de la précision et de l'exactitude des minuteries et des planificateurs système. | La méthode wait oblige le thread actuel à attendre qu'un autre thread appelle la méthode notify ou notifyAll pour l'objet. |
| Association avec Lock | |
| La méthode sleep ne libère pas le verrou sur un objet pendant la synchronisation. | La méthode wait libère le verrou pendant la synchronisation. |
| Méthode d'exécution | |
| La méthode sleep est exécutée sur le thread actuel. | La méthode wait est appelée sur l'objet. |
| Classe associée | |
| Le sommeil est une méthode de la classe Thread. | L'attente est une méthode de la classe Object. |
| Achèvement | |
| Le processus de mise en veille est terminé une fois la durée spécifiée écoulée. | La méthode wait est interrompue en appelant les méthodes notify ou notifyAll. |
Résumé - Sleep vs Wait en Java
Il existe plusieurs processus en cours d'exécution sur le système d'exploitation. Chaque processus peut avoir plusieurs threads. Un thread est la plus petite unité de traitement dans un système d'exploitation. Le langage de programmation Java prend en charge le multithreading. Il permet d'exécuter plusieurs threads simultanément. Sleep et wait sont deux méthodes pouvant être utilisées lors de l'implémentation du multi-threading. La différence entre sleep et wait en Java est que, le sleep est utilisé pour suspendre l'exécution du thread en cours pendant le nombre de millisecondes spécifié tandis que la méthode wait est utilisée pour faire attendre le thread actuel jusqu'à ce qu'un autre thread appelle le notify ou notifyAll méthode pour l'objet.
