Pages 1 | 2

Le partage du processeur : "scheduling"

Revenons sur le terme "planifié" que nous avons évoqué lors de la première étape ci-dessus.
Sur un système doté d'un processeur unique, il est évident que deux threads ne peuvent pas s'exécuter en même temps, même si le programme en donne l'illusion.
La gestion des threads repose en fait sur la planification, encore appelée "scheduling".

Les threads sont classés selon leur priorité. Celle-ci est une valeur comprise entre "MIN_PRIORITY" et "MAX_PRIORITY", (1 et 10), ce sont deux variables statiques de la classe Thread. Lorsqu'un thread est crée il lui est attribué la priorité de celui qui l'a crée (5 par défaut).
Deux threads de même priorité ont normalement la même chance de se voir allouer du temps processeur.

Il est possible de modifier cette valeur avec la méthode setPriority() :

public class threadTest extends Thread
{
     // Execution en paralllele de 2 threads non synchronises
     public static void main (String[] args)
     {
          threadTest t1 = new threadTest();
          threadTest t2 = new threadTest();
          t1.start();
          t2.start();
          System.out.println("priorite t1 par defaut : " + t1.getPriority());
          t1.setPriority(Thread.MAX_PRIORITY);
          System.out.println("priorite t1 apres modif : " + t1.getPriority());
          t2.setPriority(Thread.MIN_PRIORITY);
     }

     public void run()
     {
          for(int i = 1; i<= 10; i++)
          System.out.println(i + " " + getName());
     }
}

Contrairement à ce que nous avions obtenu en fin du tutoriel précédent, le thread "t1" ("Thread-0") prend l'avantage grâce à sa priorité maximale :

(Les "..." signale une série de ligne identique, à l'indice près)
priorite t1 par defaut : 5
1 Thread-0
... Thread-0
10 Thread-0
priorite t1 apres modif : 10
1 Thread-1
... Thread-1
10 Thread-1

Ce que nous observions la dernière fois (test effectué sous Windows 2000) dénotait d'un système d'exploitation pratiquant le "découpage de temps" ou "time-slicing". Nous allons voir à quoi cela correspond.

Lorsque plusieurs threads sont dans la file d'attente, c'est celui qui possède la priorité la plus importante qui est choisi. A noter également, un thread en cours d'exécution peut à tout moment être interrompu par l'arrivée d'un thread possédant une priorité plus importante.

Par défaut le runtime Java ne pratique pas le découpage de temps, il se base uniquement sur la priorité du thread. Cependant le scheduling diffère selon les systèmes d'exploitation.
Alors que notre "Windows" pratique le découpage de temps, d'autres systèmes permettent au thread qui a la plus haute priorité de s'exécuter jusqu'à sa mort, ce qui peut poser des problèmes si celui-ci dure trop longtemps.

La méthode yield() permet d'interrompre le déroulement d'un thread de manière presque transparente et permettre ainsi à d'autres threads de même priorité de s'exécuter. Attention, pour les systèmes d'exploitation qui ne pratiquent pas le "time-slicing", si vous choisissez d'utiliser cette méthode pour passer la main temporairement à un autre thread, n'oubliez pas d'utiliser celle-ci dans les threads susceptibles de prendre la main sans quoi le thread initial ne pourra pas reprendre.

Ces bases théoriques étant posées, nous pourrons aborder plus sereinement dans un prochain tutoriel la synchronisation des threads.

Pages 1 | 2