La programmation à objets provient du besoin d'exprimer des interactions. Jusqu'à présent, deux objets ne peuvent interagir que si l'un invoque une méthode de l'autre objet : cette forme d'interaction est ainsi limitée à la réponse d'un objet à un autre objet. Un objet actif ou agent est un objet doté d'un comportement qui lui permet d'agir sans qu'il soit sollicité par d'autres objets. En Java, un agent est une instance d'une classe réalisant l'interface Runnable. Celle-ci déclare la méthode run :
package java.lang;
public interface Runnable {
void run();
}
Le comportement d'un agent résulte de la définition de la méthode
run, dont l'exécution détermine un flot
d'instructions. Celui-ci est contrôlé en
Java par un contrôleur de processus léger, ou thread, qui
est un objet de type Thread. Selon la plate-forme, ce mécanisme
peut être pris en charge par le système d'exploitation, ou bien être
gérés à l'intérieur de la JVM. Quand une application est démarrée,
l'environnement Java crée toujours un thread exécutant la fonction
main de l'application : c'est le processus léger principal.
D'autres processus légers peuvent être créés, soit par l'environnement
d'exécution, soit par l'application. Chacun de ces processus légers
exécute une fonction, en concurrence avec les autres ; ils
communiquent entre eux via des objets partagés. C'est la
programmation multithread, domaine important en terme
d'applications, mais qui dépasse le cadre de ce cours.
Pour définir un nouveau processus léger, on doit d'abord créer son contrôleur, une instance de la classe Thread associée à un agent et on le démarre par la méthode start().
package exemples;
Class Agent implements Runnable {
// ...
public void run() { ... }
}
Class TestAgent {
public static void main(String[] args) {
Agent a = new Agent(...);
Thread t = new Thread(a); // t contrôle a
t.start(); // t démarre a
// ...
}
}
Un processus léger, une fois initialisé par un constructeur de Thread est dans l'état initial. L'invocation t.start(), qui retourne immédiatement, le fait passer dans l'état actif, dans lequel il peut être effectivement exécuté (sur un monoprocesseur, il sera exécuté en temps partagé avec les autres processus légers ; sur un multi-processeur, il peut être exécuté en parallèle avec les autres) : il exécute alors la méthode run de l'agent qu'il contrôle. Il faut noter que la méthode run n'est pas appelée explicitement dans le programme (exactement de la même façon que la méthode main d'une application).
Le processus léger passe dans l'état suspendu quand :
Le processus léger passe dans l'état terminé quand la méthode run termine.
L'exemple suivant montre deux agents, l'un émettant un 'a',
l'autre un 'b' à des instants aléatoires :
package exemples;
class Concurrence {
public static void main(String[] args) {
Agent
a = new Agent('a'),
b = new Agent('b');
a.start();
b.start();
}
}
Chaque agent est une instance de la classe suivante, qui redéfinit la méthode run de Thread :
package exemples;
class Agent implements Runnable {
char c;
private Thread contrôleur;
Agent(char c) {
this.c = c;
contrôleur = new Thread(this);
}
public void run() {
while (true) {
System.out.print(c);
try {
Thread.sleep((long)(Math.random()*1000));
} catch (InterruptedException e) {}
}
}
}
L'exécution de la classe exemples.Concurrence affiche une suite de caractères, résultat de l'entrelacement des flots d'instructions de chaque agent :
baabababbabbaaababbabbbbaabbabaaababbabababaa ...
La programmation multithread est un aspect important de la programmation des systèmes logiciels contemporains.