Priorité des threads Java

Considéré comme la « plus petite unité de traitement », Thread est un sous-processus léger chargé d'un certain travail qui doit être effectué. Les threads partagent le même emplacement mémoire qui leur est attribué et sont indépendants les uns des autres, favorisant ainsi le multitâche. Mais lorsque plusieurs threads s'exécutent sur l'emplacement de mémoire partagé, une compétition sur la ressource est inévitable. Pour éviter cette concurrence et permettre d'atteindre un débit élevé, un concept de priorisation des threads a été introduit. Cela revêt une grande importance lorsque plusieurs tâches sont exécutées sur le même système. Le « planificateur de threads effectue le travail d'attribution des threads en cours d'exécution selon la priorité ».

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

JVM (machine virtuelle JAVA) prend la décision de prioriser les threads par défaut ou explicitement par le programmeur. Le degré de priorité varie entre 1 et 10, 10 étant attribué lorsque l'on souhaite donner au thread la priorité la plus élevée. Les changements de changement de contexte facilitent la transition du thread 1 au thread 2 et ainsi de suite selon l'ordre de priorité.

Remarque : Il peut y avoir une chance que deux threads ou plus soient attribués avec la même priorité, leur exécution dépend alors du système d'exploitation. Par exemple, Windows utilise un algorithme round-robin pour gérer ce cas.

Variables de la priorité des threads Java

Il existe trois variables principales pré-enregistrées dans JAVA sous forme de macros qui sont expliquées ci-dessous-

• Public Static int MIN_PRIORITY : Il s'agit d'une variable statique avec un modificateur d'accès de type « public ». Cette variable reçoit la valeur 1. Il s'agit d'attribuer un thread avec la priorité la plus basse.
• Public Static int NORM_PRIORITY : Il s'agit d'une variable statique avec un modificateur d'accès de type « public ». Cette variable reçoit la valeur 5. Il s'agit d'attribuer un thread avec une priorité normale. Il s'agit d'une priorité par défaut lorsque la priorité n'est pas attribuée explicitement par le développeur.
• Public Static int MAX_PRIORITY : Il s'agit d'une variable statique avec un modificateur d'accès de type « public ». Cette variable reçoit une valeur de 10. Il s'agit d'attribuer un thread avec la priorité la plus élevée.

Certaines fonctions associées à l'obtention et à la définition de la priorité sont :

• Public Final int getPriority (): Cette fonction est utilisée pour obtenir la priorité de n'importe quel fil demandé. Cette fonction renvoie un entier car son type de retour est « int ». L'entier peut être compris entre 1 et 10. La fonction est publique et définitive.
• Public Final void setPriority (int newPriority) : Cette fonction est utilisée pour définir la priorité de tout fil de discussion demandé. Cette fonction prend un entier comme paramètre, et celui-ci est mentionné dans le prototype de paramètre dans la définition de la fonction. Le paramètre entier peut être compris entre 1 et 10. La fonction est publique et définitive.

Exemples de priorité des threads Java

Voici quelques exemples de priorité des threads Java :

Exemple n°1

Vous trouverez ci-dessous quelques exemples illustrant le concept de priorité des threads en utilisant les variables déjà définies ci-dessus et les fonctions prêtes à l'emploi disponibles en JAVA.

Code :

public class test extends Thread{
public void run (){
System.out.println ( "The name of thread running curremtly is :"+Thread.currentThread ().getName ());
System.out.println ( "The priority od thread running currently is:"+Thread.currentThread ().getPriority ());
}
public static void main (String args[]){
test t1=new test ();
test t2=new test ();
test t3=new test ();
t1.setPriority (Thread.MIN_PRIORITY);
t2.setPriority (Thread.MAX_PRIORITY);
t3.setPriority (Thread.NORM_PRIORITY);
t1.start ();
t2.start ();
t3.start ();
}
}

Sortie :

Exemple n°2

Vous trouverez ci-dessous un exemple de définition et d'impression de priorités définies par l'utilisateur.

Code :

public class test2 extends Thread
{
public void run ()
{
System.out.println ( " The control is under run function now...");
}
public static void main (String args[])
{
// Here we are creating threads using the constructors.
test2 t1=new test2 ();
test2 t2=new test2 ();
// setpriority () function is used below along with the parameter to set the prioirity.
t1.setPriority (2);
t2.setPriority (9);
// Here we are coding on how to display output strings.
System.out.println ( " The priority assigned to thread t1 is: " + t1.getPriority ());
System.out.println ( "The priority assigned to thread t2 is: " + t2.getPriority ());
// the run () function is defined above will be called via start () function and print the strinf which is there in it.
t1.start ();
}
}

Sortie :

Remarque : La priorité doit être strictement comprise entre 1 et 10. Si la priorité se situe en dehors de cette plage, le compilateur renvoie l'erreur ci-dessous. J'ai eu cette erreur lorsque 13 a reçu une priorité à la place de 9 lors de la définition d'une priorité du thread t2 à l'aide de la fonction setPriority ().

Exception :

Exception dans le fil de discussion « principal » java.lang.IllegalArgumentException

sur java.base/java.lang.Thread.setPriority (Thread.java:1141)

à test2.main (test2.java:14)

Avantages de la priorité des threads Java

Il existe de nombreux avantages associés au multithreading et à l'attribution de la priorité aux threads répertoriés ci-dessous :

• Il permet d'effectuer plusieurs opérations simultanément dans le système, ainsi que la priorité du thread. Par exemple, l'utilisateur navigue sur Internet mais interrompt soudainement le système car un nouveau logiciel a été installé. Dans ce cas, la priorité est donnée au redémarrage du système via la navigation sur Internet.
• Le thread JAVA hérite de sa priorité de la bande de roulement parent si le programmeur ne définit pas explicitement la priorité du thread. Il y a conservation de la priorité en contournant la priorité dans les threads en aval et en maintenant la symétrie. Cela facilite le débogage du programme par les programmeurs.
• Cela rend un code plus simple donc facile à maintenir.
• Cela facilite grandement le travail de changement de contexte en attribuant des priorités.

Conclusion

C'est l'un des moyens les plus utilisés et efficaces d'exécuter plusieurs tâches dans le même système. Étant donné que les threads partagent la mémoire, cette méthode est également efficace en termes de mémoire. Nous pouvons faire fonctionner plusieurs threads dans le système, mais cela peut confondre le processeur sur lequel choisir en premier. Ce problème a été résolu en attribuant des priorités au fil de discussion. Le thread continue de s'exécuter jusqu'à ce qu'il se termine ou soit interrompu par un thread de priorité plus élevée. Cette fonctionnalité fonctionne en étroite collaboration avec le système d'exploitation. Préparer des documents Word et surfer sur Internet avec de la musique n'était pas aussi efficace jusqu'à l'avènement du concept magique du multi-threading.

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!