Cours Thread et Communication en Java

Date de publication : 10/04/2005 , Date de mise a jour : 10/04/2005

Par Emmanuel Viennet (http://viennet.developpez.com/)
 

Le cours thread et communication en Java permettra aux étudiants les bases de la gestion des processus dans un système d'exploitation.

I. Rappel sur les processus

Un processus peut être dans différents états. Voici une présentation simplifiée des états possibles :
• En exécution (running) : le processus s'exécute sur un processeur du système;
• Prêt : le processus est prêt à s'exécuter, mais n'a pas le processeur (occupé par un autre processus en exécution);
• Bloqué : il manque une ressource (en plus du processeur) au processus pour qu'il puisse s'exécuter

Figure 1: Transitions entre états d'un processus.

II. Threads

II-A. Introduction

II-B. Rappel : Notion d'interface en Java

Une interface permet de d'établir un ensemble de comportements abstraits définissant un contrat que va respecter une classe.
• spécification d'un protocole en termes de signatures de méthodes abstraites (sans corps);
• une interface ne contient pas de code;
• une interface ne peut avoir de variables membres mais peut avoir des constantes de classes (variables statiques et finales).
• une classe qui implémente une interface s'engage à remplir le contrat, à donner un corps à toutes les méthodes de l'interface.

public interface Colorable {
    void setColor(byte r, byte g, byte b);
}// end Colorable 

class Point2D {
    int x, y;
}// end Point2D 

class ColoredPoint extends Point2D implements Colorable {
    byte r, g, b;
    public void setColor(byte rv, byte gv, byte bv) {
        r = rv; g = gv; b = bv;
    }
}// end ColoredPoint

II-C. Création d'un thread

II-C-1. Héritage de la classe Thread

class MonThread extends Thread {
    MonThread() {
            ... code du constructeur ...
    }

    public void run() {
            ... code a executer dans le thread ...
    }
}

MonThread p = new MonThread();
p.start();

II-C-2. L'interface Runnable

class MonThread2 implements Runnable {
    MonThread2() {
        ... code du constructeur ...
    }

    public void run() {
        ... code a executer dans le thread ...
    }
}

public static void main(String[] args)  {
	MonThread2 p = new MonThread2();
	Thread t = new Thread(p);
	t.start();
}

II-D. Méthodes de la classe Thread

• sleep( long ms ) : le thread qui appelle sleep() est bloqué pendant ms millisecondes (d'autres threads à l'état peuvent alors s'exécuter).
• isAlive() : retourne vrai si le thread auquel on applique la méthode est vivant (c'est à dire à été démarré par start() et que sa méthode run() n'est pas encore terminée. Le thread vivant est donc prêt, bloqué ou en cours d'exécution.
• getPriority() et setPriority( int prio ) permettent de manipuler la priorité du thread.

II-E. Partage de la mémoire entre Threads

//: exemplePartage.java
public class exemplePartage extends Thread {

    private static String chaineCommune = "";
    private String nom;

    exemplePartage ( String s ) {
        nom = s;
    }

    public void run() {
        chaineCommune = chaineCommune + nom;
    }

    public static void main(String args[]) {
        Thread T1 = new exemplePartage( "T1" );
        Thread T2 = new exemplePartage( "T2" );
        T1.start();
        T2.start();
        System.out.println( chaineCommune );
    }
}

• Aucun affichage : le thread principal affiche chaineCommune avant que le système n'ai donné la main aux threads T1 et T2
• T1 : au moment de l'affichage, le thread T1 s'est exécuté, mais pas T2
• T2 : idem
• T1T2 ou T2T1 : les deux threads se sont exécutés, dans un ordre arbitraire

II-F. Synchronisation

II-F-1. Un problème d'accès concurrent

//: exempleConcurrent.java
public class exempleConcurrent extends Thread {

	private static int compte = 0;

    public void run() {
		int tmp = compte;
		try {
			Thread.sleep(1); // ms
		} catch (InterruptedException e) {
			System.out.println("ouch!\n");
			return;
		}
		tmp = tmp + 1;
		compte = tmp;
    }

    public static void main(String args[]) throws InterruptedException {
		Thread T1 = new exempleConcurrent();
		Thread T2 = new exempleConcurrent();
		T1.start();
		T2.start();
		T1.join();
		T2.join();
        System.out.println( "compteur=" + compte );
    }
}

II-F-2. Mot clé synchronized

II-F-3. Synchronisation temporelle : wait et notify

• wait() : le thread qui appelle cette méthode est bloqué jusqu'à ce qu'un autre thread appelle notify() ou notifyAll(). Notons que wait() libère le verrou, ce qui permet à d'autres threads d'exécuter des méthodes synchonisées du même objet.
• notify() et notifyAll() permettent de débloquer une tâche bloqué par wait(). Attention, si une tâche T1 appelle wait dans une méthode de l'objet O, seule une autre méthode du même objet pourra la débloquer; cette méthode devra être synchronisée et exécutée par une autre tâche T2.

//: Evenement.java
// Classe simulant la notion d'événement
//	S. Szulman 1998
public class Evenement
{
	private Boolean Etat; // etat de l'evenement 
	public Evenement() {
		Etat = Boolean.FALSE;
	}
	public synchronized void set() {
		Etat = Boolean.TRUE;
        // debloque les threads qui attendent cet evenement:
		notifyAll();
	}
	public synchronized void reset() {
		Etat = Boolean.FALSE;
	}
	public synchronized void attente() {
		if(Etat==Boolean.FALSE) {
			try {
				wait(); // bloque jusqu'a un notify()
			}
			catch(InterruptedException e) {};
		}
	}// fin attente
}// fin classe

II-F-4. Interblocages

III. Tubes de communication

Figure 2: Tube de communication.

III-A. Tubes entre processus UNIX

III-A-1. Enchainement de commandes en shell

$ ps -au | grep napster

III-A-2. Création d'un tube

III-A-3. Lancement d'une commande reliée par un tube

FILE *popen( char *command, char *mode );

III-B. Tubes entre threads JAVA

PipedWriter out = new PipedWriter();
PipedReader in;
try {
    in = new PipedReader(out);
} catch (IOException e) { ... }

• PipedWriter est une sous-classe de Writer, et possède donc une méthode write() que l'on appelle pour écrire des données dans le tube.
• PipedReader, sous-classe de Reader, a diverses méthodes read() permettant de lire un ou plusieurs caractères depuis le tube.

Auteur

L'auteur Emmanuel Viennet est maitre de conférences à l'IUT de Villetaneuse, et membre de l'équipe Apprentissage, Diagnostic et Agents (ADAge) du laboratoire d'informatique (LIPN). Pour en savoir plus, rendez-vous sur son site :  Laboratoire d'Informatique de l'université Paris Nord.

Bibliographie

• Thinking in JAVA ( traduit en français), par Bruce Eckel, Prentice Hall (le texte du livre et les exemples en JAVA sont disponibles gratuitement sur http://www.bruceeckel.com). Ouvrage très complet et clair sur le langage, couvrant aussi les aspects multitâches (threads) et réseaux (sockets).
• JAVA La synthèse, par Gilles Clavel et al., InterEditions. Ouvrage d'introduction à JAVA en français. Un court chapitre sur les threads dans le cadre des applets.
• Concurrent Programming in JAVA, par Doug Lea, Addison Weysley. Ouvrage spécialisé sur les aspects multitâches de JAVA (synchronisation de threads).
•  Java Sun : logiciels, documentations et exemples sur JAVA.
• Concernant la programmation système en C et le détail des appels systèmes d'UNIX, nous conseillons les ouvrages en français de J.M. Rifflet, La programmation sous UNIX publié par Ediscience, et de R. Card Programmation Linux 2.0, publié par Eyrolles.