L'ordre d'exécution des threads en attente peut être géré par l'intermédiaire de l'affectation d'un niveau de priorités déterminé à chaque unité d'exécution créée.

La gestion des threads est parfois dépendante du système d'exploitation sous-jacent, si bien que le thread possèdant la priorité la plus élevé, peut ne pas être exécuté prioritairement. Sur les systèmes Unix et Macintosh, les priorités sont gérées rigoureusement, ce qui n'est pas le cas de tous les systèmes Microsoft, tel que Windows 95.

Normalement, le système d'exploitation devrait exécuter le thread possèdant la priorité la plus grande. Lorsque des threads possèdent des priorités égales, alors le premier dans la file d'attente est exécuté par le processeur.

Afin d'obtenir un fonctionnement identique sur n'importe quel système d'exploitation, il peut être préférable de contrôler l'ordre d'exécution des threads par l'intermédiaire des méthodes sleep() ou yield(), permettant de mettre en pause le thread courant afin que d'autres puissent s'exécuter également.

Les priorités des threads se situent dans un intervalle de 1 à 10. Trois constantes représentent les valeurs limites et médianes. Plus la valeur de la priorité est élevée, plus grande sera la priorité du thread pour l'accès au processeur.

MIN_PRIORITY : priorité minimum (1)
NORM_PRIORITY : priorité normale (5)
MAX_PRIORITY : priorité maximum (10)

La priorité normale est affectée par défaut à un nouveau thread.

Les threads exécutés automatiquement par la machine virtuelle Java, possèdent des niveaux de priorités prédéterminés. Par exemple, la priorité du thread Finalizer est fixée à 8, tandis que celle du thread principal vaut 5.

NiveauThread
4Screen Updater
5Thread utilisateur (défaut)
5main
5SunToolkit.PostEventQueue-0
5Signal dispatcher
5AWT-Windows
6AWT-EventQueue-0
8Finalizer
10Reference Handler
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JTextField;

public class AppliCompteur extends JPanel implements Runnable {
  private Thread threadEnCours;

  private JTextField txtCompteur;

  private volatile boolean demarre;
  private volatile boolean suspension;
  private volatile boolean arret;

  public AppliCompteur() {
    afficherInfos("Construction de l'interface graphique");
    demarre = true;
    arret = true;
    suspension = false;

    txtCompteur = new JTextField();
    txtCompteur.setEditable(false);

    JButton btnSuspension = new JButton("Suspendre");
    JButton btnReprendre = new JButton("Reprendre");
    JButton btnDemarrer = new JButton("Démarrer");
    JButton btnTerminer = new JButton("Terminer");

    btnSuspension.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        afficherInfos("Suspension");
        suspendre();
      }
    });
    btnReprendre.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        afficherInfos("Reprendre");
        reprendre();
      }
    });
    btnDemarrer.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        afficherInfos("Démarrer");
        demarrer();
      }
    });
    btnTerminer.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        afficherInfos("Terminer");
        sortir();
      }
    });
    this.setLayout(new GridLayout(5, 1, 3, 3));
    this.add(txtCompteur);
    this.add(btnDemarrer);
    this.add(btnSuspension);
    this.add(btnReprendre);
    this.add(btnTerminer);
  }
  private void suspendre() {
    suspension = true;
  }
  private void reprendre() {
    suspension = false;
  }
  private void demarrer() {
    if (demarre)
      arret = false;
  }
  public void sortir() {
    arret = true;
    demarre = true;
  }
  private void attendreDemarrage() throws InterruptedException {
    while (demarre && arret) {
      Thread.sleep(200);
    }
    demarre = false;
  }
  private void attendreSuspension() throws InterruptedException {
    while (suspension) {
      Thread.sleep(200);
    }
  }
  private void afficherInfos(String origine) {
    System.out.println(origine + " -> " 
                     + Thread.currentThread().getName() + " ( " 
                     + Thread.currentThread().getPriority() + " )");
  }
  public boolean verifierPremier(long nombre) {
    if (nombre < 0) {
      return false;
    }
    else if (nombre < 4) {
      return true;
    }
    else {
      for (int i = 2; i <= nombre / 2; i++) {
        if (nombre != i && nombre % i == 0) {
          return false;
        }
      }
    }
    return true;
  }
  public void run() {
    try {
      threadEnCours = Thread.currentThread();
      afficherInfos("Exécution du thread utilisateur");
      while(true) {
        this.attendreDemarrage();
        long compteur = 0;
        while (!arret) {
          if (verifierPremier(compteur)) {
            NombrePremier objet = new NombrePremier(
                                           String.valueOf(compteur));
            this.txtCompteur.setText(objet.getValeur());
            Thread.sleep(500);
          }
          compteur++;
          this.attendreSuspension();
        }
      }
    }
    catch (InterruptedException e) {
      Thread.currentThread().interrupt();
    }
    finally {
      threadEnCours = null;
    }
  }
  public static void main(String[] args) {
    final AppliCompteur appli = new AppliCompteur();
    appli.afficherInfos("Programme principal");
    final Thread t = new Thread(appli);
    t.setName("Compteur");
    t.start();
    JFrame f = new JFrame("Démonstration");
    f.setContentPane(appli);
    f.pack();
    f.setVisible(true);
    f.addWindowListener(new WindowAdapter() {
      public void windowClosing(WindowEvent e) {
        appli.afficherInfos("Gestionnaire de fenêtre");
        t.interrupt();
        System.exit(0);
      }
    });
  }
}

public class NombrePremier {
  private String valeur;
  public NombrePremier(String valeur) {
    this.valeur = valeur;
  }
  public String getValeur() {
    return this.valeur;
  }
  public void setValeur(String valeur) {
    this.valeur = valeur;
  }
  protected void finalize() throws Throwable {
    System.out.println("Nombre premier [ " + valeur + " ] -> " 
         + Thread.currentThread().getName() + " ( " 
         + Thread.currentThread().getPriority() + " )");
    this.valeur = null;
  }
}

/* Affiche :
Construction de l'interface graphique -> main ( 5 )
Programme principal -> main ( 5 )
Exécution du thread utilisateur -> Compteur ( 5 )
Démarrer -> AWT-EventQueue-0 ( 6 )
Nombre premier [ 257 ] -> Finalizer ( 8 )
Nombre premier [ 251 ] -> Finalizer ( 8 )
Nombre premier [ 241 ] -> Finalizer ( 8 )
...
Nombre premier [ 2 ] -> Finalizer ( 8 )
Nombre premier [ 1 ] -> Finalizer ( 8 )
Nombre premier [ 0 ] -> Finalizer ( 8 )
Suspension -> AWT-EventQueue-0 ( 6 )
Reprendre -> AWT-EventQueue-0 ( 6 )
Terminer -> AWT-EventQueue-0 ( 6 )
Gestionnaire de fenêtre -> AWT-EventQueue-0 ( 6 )
*/
Sommaire