Gérer les priorités du multithread en Java

La création de plusieurs threads permet d'exécuter différentes activités en parallèle. Pour éviter les conflits d'accès aux ressources et la saturation du processeur, il est nécessaire de gérer leur priorité.

Un thread, ou processus léger, est l'exécution d'un ensemble d'instructions dans un même environnement. En Java, le thread s'appuie sur l'interface native du système d'exploitation (les threads du système), il n'est pas géré directement par la machine virtuelle. 

En cas d'utilisation de plusieurs threads, on parle de multithread. La classe Thread en Java est le support de base du multithread. Elle contient les instructions pour la création, l'exécution ou l'arrêt d'un thread. Un nouveau thread se crée avec la méthode run() et doit être démarré avec start(). Il est mis en arrêt avec yield() ou sleep(long delai).

Le gestionnaire des tâches, appelé scheduler, gère les threads selon la priorité qui leur a été attribuée. Les threads MIN_PRIORITY(0), pour les tâches de fonds, s'exécutent quand les autres threads sont inactifs. Les threads NORM_PRIORITY (5), qui est la priorité par défaut, s'exécutent les uns après les autres sauf si un thread de haute priorité se lance.

Enfin, les threads MAX_PRIORITY(10) sont réservés aux tâches très importantes, ils doivent rester exceptionnels. SetPriority(int) permet de modifier la priorité à tout moment. En cas de threads de priorités identiques, ils seront régulièrement interrompus par le scheduler pour laisser la main à leurs homologues. Le délai d'interruption, MaxWait (attente maximale) est défini par le système d'exploitation. 

 

Pour éviter les conflits d'accès de plusieurs threads à une même information, il faut les synchroniser. Sur chaque objet créé dans la JVM, un verrou est ajouté avec l'instruction synchronized. Ainsi, un seul thread à la fois peut accéder à une variable. Une file d'attente est créée dans le moniteur. L'utilisation des verrous nécessite une vérification du traitement, d'où un léger ralentissement.

 

Utiliser les exceptions en Java permet de gérer les erreurs à la fois internes et fonctionnelles des threads. Les instructions susceptibles de provoquer une exception sont isolées dans un bloc de try suivi de blocs de catch qui contiendront les traitements des différentes exceptions. La documentation des classes indique toutes les exceptions possibles d'une méthode.

 

Implémentation :

 

Class MonThread extends Thread{                //MonThread hérite de Thread

 

 public void run(){                                           //code à exécuter par le thread

   System.out.println(nom+ ": démarrage");         

   synchronized (this){                                     //synchronisation du thread

       try { yield();                                     //arrêt du thread dans le bloc try   

       } catch (InterruptedException e) {     //capture de l'exception si erreur

           //traitement de l'exception e }             

    }

 }

 

 public static void main (string [] args){

   MonThread t1=new MonThread ();               //création du thread t1

   t1.setPriority(MAX_PRIORITY);                   //priorité maximale

   t1.start();                                                  //démarrage de t1

   MonThread t2=new MonThread ();        //création du thread t2

   t2.start();                                        //démarrage de t2 (quand t1 sera arrêté)

 }

 

}

 

 

Les méthodes de la classe Thread sont disponibles sur la plate-forme Java de Sun.

 

Processeur