Différence clé - veille vs attente en Java
Sleep et 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 actuel pendant le nombre spécifié de millisecondes tandis que la méthode wait est utilisée pour faire attendre le thread actuel jusqu'à ce qu'un autre thread invoque la notification ou méthode notifyAll pour l'objet.
Un thread est la plus petite unité de traitement du système d'exploitation. Il s'agit d'un seul flux séquentiel 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.
Qu'est-ce que le sommeil en Java ?
Plusieurs processus sont 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 manières de créer un thread. C'est-à-dire 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 threads. Un seul thread s'exécute dans un seul processus.
Un thread passe par plusieurs phases. Après avoir créé un objet de la classe Thread, le programmeur peut invoquer la méthode start. Avant d'invoquer cette méthode, on dit que le thread est dans le nouvel état. Le planificateur de thread 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 start est invoquée, alors le thread est dans un état exécutable. Une fois que le planificateur de threads a sélectionné le thread à exécuter, il passe à l'état d'exécution. Si le thread est actif mais qu'il n'est pas actuellement éligible à l'exécution, il est alors dans un état non exécutable ou bloqué. Après l'achèvement de la méthode run, 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 thread pour effectuer différentes tâches. La méthode de mise en veille est utilisée pour mettre en veille la méthode pendant une durée spécifique. La syntaxe de la méthode sleep est la suivante: public void sleep (longues millisecondes) lance InterruptedException. Il provoque l'arrêt temporaire de l'exécution du thread en cours d'exécution pendant un nombre spécifié de millisecondes. Si un autre thread interrompt le thread en cours, l'état interrompu du thread en cours est effacé lorsque cette exception est levée.
Figure 01: Programme Java avec la méthode sleep
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 invoqué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.dormir (1000); permettra au premier thread de terminer l'exécution pendant 1000 millisecondes. Lorsqu'un thread dort, le planificateur de threads 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 faire en sorte qu'un seul thread accède à la ressource partagée. Supposons une situation comme suit. S'il existe deux threads en tant que t1 et t2, t1 commence à enregistrer les valeurs dans un fichier texte appelé Text1.txt. Ces valeurs seront utilisées pour un autre calcul lors du retour de t1. Si t2 démarre avant le retour de t1, t2 peut modifier les valeurs enregistré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é, de sorte qu'il n'est accessible que par t1. Le t2 ne peut pas le modifier tant que t1 n'a pas relâché le verrou pour accéder à ce fichier texte. Lorsque la tâche est terminée, le t1 peut libérer le verrou. La serrure est également connue sous le nom de moniteur.
La synchronisation des threads peut être réalisée par une 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é à l'aide des 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 invoque la méthode notify ou notifyAll pour l'objet. La méthode notify 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 à l'intérieur de la méthode run. La boucle for et la méthode de notification se trouvent à l'intérieur du bloc synchronized. Dans la méthode principale, une instance d'un thread est créée et la méthode start est appelée sur cette instance. La méthode main 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 notify. Une fois la méthode notify appelée, la méthode main arrête d'attendre et commence à exécuter le reste du code. Main attend que le fil de la 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, la sortie sera nulle car elle n'attend pas que l'autre thread se termine.
Calculatrice t1=nouvelle Calculatrice ();
t1. commencer ();
System.out.println (t1.sum);
Quelle est la similitude entre le sommeil et l'attente 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 ?
sleep vs wait en Java |
|
| La méthode sleep entraîne la suspension de l'exécution du thread actuel pendant le nombre de millisecondes spécifié, sous réserve de la précision et de l'exactitude des temporisateurs et des planificateurs du système. | La méthode wait fait attendre le thread actuel jusqu'à ce qu'un autre thread invoque la méthode notify ou notifyAll pour l'objet. |
| Association avec la serrure | |
| La méthode sleep ne libère pas le verrou sur un objet pendant la synchronisation. | La méthode d'attente libère le verrou pendant la synchronisation. |
| Méthode d'exécution | |
| La méthode sleep est exécutée sur le thread courant. | La méthode d'attente est appelée sur l'objet. |
| Classe associée | |
| Le sleep est une méthode de la classe Thread. | Le wait est une méthode de la classe Object. |
| Achèvement | |
| Le processus de mise en veille est terminé une fois le temps spécifié écoulé. | La méthode d'attente est interrompue par l'appel des méthodes notify ou notifyAll. |
Résumé - sommeil vs attente en Java
Plusieurs processus sont 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. Le sommeil et l'attente sont deux méthodes qui peuvent être utilisées lors de la mise en œuvre 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 spécifié de millisecondes tandis que la méthode wait est utilisée pour faire attendre le thread en cours jusqu'à ce qu'un autre thread invoque la notification ou notifyAll méthode pour l'objet.
