Création d’un thread (Solution 2) Exemple

Java ne permet pas l'héritage multiple de classes : PB: Comment hériter

d'une autre classe? public class MyRunnable implements
 Solution implémenter l’interface Runnable (possède une seule méthode : public Runnable { public static void main(String[] args){
void run() ) MyRunnable r = new MyRunnable();
public void run() {
Thread t1= new Thread(r,”t1”);
[Link]("LeThread
1) Créer une classe qui implémente l’interface Runnable commence");
Thread t2= new Thread(r,”t2”);
[Link]();
public class MyRunnable implements • faire exécuter un même for (int i=0; i<10; i++) { [Link]();
Runnable { } Runnable à plusieurs threads. for (int i=0; i<5; i++) {
[Link]("Thread en
2) Redéfinir la méthode run • Séparer le traitement de son
étape, en " + i);
[Link]("Principal, en "
public void run() { // traitement à environnement d’exécution. + i);
try {[Link](500);}
réaliser } try {[Link](500);}
catch (InterruptedException
catch (InterruptedException ie) {
3) Créer un objet runnable ie) {
[Link]();}
MyRunnable runnable = new [Link]();} }
MyRunnable(); } [Link]("Principal se
4) Créer un objet Thread (déléguer l’exécution) [Link](« le thread termine");
Thread t1 = new Thread(runnable); termine }
Thread t2 = new Thread(runnable); son job");
4) Lancer le Thread }
[Link]();
[Link](); 34 35

Thread Démon Jointure d’un Thread

 Un thread peut avoir à attendre la fin d’un autre pour continuer son
Deux sortes de threads:
 Thread utilisateurs : Threads de haute priorité. traitement: join()
 La méthode join() fait attendre la fin d’un thread (appelé) par le thread en cours
 Threads démons: Threads qui fournissent des services support (en arrière plan) aux
d’exécution (appelant).
thread utilisateurs.
 Elle permet de s’assurer que le traitement du thread est terminé avant de
Exemple de démon JVM: garbage collector, poursuivre le déroulement du programme.
Méthodes utiles:  Il est également possible de spécifier le temps maximal d’attente à l’aide des
 setDaemon (boolean b) // à exécuter avant méthode start surcharges join(long)
 boolean isDaemon( ) public static void main(String[] args){
MyRunnable r = new MyRunnable();
Thread t1= new Thread(r,”t1”);
La JVM ferme un processus lorsque les seuls threads en cours d'exécution Thread t2= new Thread(r,”t2”);
[Link](" prog Principal commence… ");
sont tous des threads démons. [Link]();
[Link]();
[Link]("Principal attend la terminaison des tâches avant de continuer
");
try{
[Link]();
[Link]();
}catch (InterruptedException ie) { [Link]();}
[Link]("les threads ont terminé");
// traitement à faire après la terminaison de t1 et t2
[Link]("prog Principal termine…");
36 } 37
Arrêter un thread Arrêter un thread
Cas1: Le Thread est dans l’état bloqué ou en attente (wait, sleep, I/O, etc.)):
Un thread s’arrête automatiquement une fois la méthode run()  l'appel bloquant lève une exception InterruptedException ou InterruptedIOException
est fini.
Cas2: [Link]() rend le flag interrupted à true
Arrêter le thread de façon volontaire :  Le flag peut être utiliser pour arrêter le thread explicitement (via programmation)
 Méthodes « deprecated » : stop(), destroy(), suspend(), resume()  Les méthodes boolean isInterrupted() et boolean interrupted() sont utilisées pour savoir si le
thread a été interrompu
Méthodes « unsafe »: peuvent provoquer une situation // Cas1: Exemple interruption avec appel
bloquant
// Cas2: Exemple interruption sans appel bloquant
anormale (ex. deadlock) public void run() {
public void run() {
[Link]("LeThread commence");
[Link]("LeThread commence"); while(worktodo) {
Meilleure façon: Arrêt du thread via un mécanisme coopératif while(true) {
// traitement
if(![Link]()){// traitement}
else{// traitement à faire si interropu}
méthode interrupt() try {[Link](500);}// appel }
bloquant }
catch (InterruptedException ie) {}
}
}
public static void main(String[] args){
MyThread t1 = new MyThread();
[Link](" prog Principal commence… ");
[Link]();
[Link]("Principal interrompe l’exécution du thread ");
try{ [Link]();}catch (InterruptedException ie) { }
// traitement à faire après….
38 39
[Link]("prog Principal termine…");
}

Priorité d’un thread et ordonnancement Groupe de threads

Question: quel thread va s’exécuter maintenant? Comment manipuler plusieurs threads comme une seule entité afin de les
suspendre, reprendre,etc.
Réponse: le thread qui a la plus grande priorité parmi les
Solution: utiliser des groupes de threads : [Link]
threads prêts.  on regroupe un ensemble de threads
Par défaut, chaque nouveau Thread a la même priorité que le  ils seront manipulés comme une seule entité
Thread qui l’a crée. ThreadGroup (String name) crée un groupe de threads
avec le nom donné.
Pour changer la priorité [MIN_PRIORITY, MAX_PRIORITY] d’un
ThreadGroup (ThreadGroup crée un groupe de threads
thread : parent, String name) avec le groupe parent et le
 int getPriority ( ) nom donné.
 void setPriority ( int p )
la JVM crée au minimum un groupe de threads nommé main
 Thread.MIN_PRIORITY (1), Thread.MAX_PRIORITY(10), par défaut, un thread appartient au même groupe que celui qui l’a crée
Thread.NORM_PRIORITY(5) (son père)
On peut construire une hiérarchie de threads et de threadGroup
getThreadGroup() : pour connaître son groupe

40 41
Groupe de threads (Exemple) Partage d’information
Deux façons pour partager des données entre les threads:
public class ThreadGroupTest implements Runnable{ Les variables statiques: variable de classe partagée par toutes les instances d’une
public void run() {
classe.
[Link]([Link]().getName());  Exemple: static volatile int compteur = 0 ;
} volatile oblige la JVM à rafraichir son contenu à chaque utilisation.
public static void main(String[] args) {
ThreadGroupTest runnable = new ThreadGroupTest(); Constructeur Thread(Runnable): Créer plusieurs threads à travers (constructeur de
ThreadGroup gp= new ThreadGroup("Parent la classe Thread) un même objet runnable.
ThreadGroup");
Thread t1 = new Thread(gp, runnable,"one");
 Exemple: public static void main(String[] args){
[Link](); MyRunnable r = new MyRunnable();
Thread t2 = new Thread(gp, runnable,"two");
[Link]();
Thread t1= new Thread(r,”t1”);
Thread t3 = new Thread(gp, runnable,"three"); Thread t2= new Thread(r,”t2”);
[Link](); // l’objet r est partagé entre les
[Link]("Thread Group Name: thread t1 et t2
"+[Link]());
[Link](); [Link]();
} [Link]();
} }

42 43

Exercice Accès concurrent

deux threads veulent incrémenter a, la valeur final doit être a+2
a=0;
Thread 1 a=a+1; Thread 2

Opération non
1. Load charger a atomique
Ecrire un programme qui crée trois threads incrémentant une 2. Add incrémenter a
même variable Interférence 1. Load charger a
2. Add incrémenter a
3. Store remettre la somme
dans a
3. Store remettre la somme
dans a

Exécution non déterministe: Le résultat peut être 2

ou 1 !!!!!

44 45
Exclusion mutuelle et section critique Accès concurrent
L’exécution d’une suite d’instructions (non atomique) peut engendrer des incohérences
L'exclusion mutuelle est une méthode qui permet de s'assurer que si Problème Comment être sur que la portion du code (variable partagée) sera exécuter
un thread utilise une ressource partagée, les autres processus seront par un seul thread à tout moment?
excluent de la même activité.
Solution Utiliser un mécanisme d’exclusion mutuelle pour contrôler l’accès à une
Section critique: portion du programme à partir de laquelle on ressource partagée.
accède à une ressource partagée. En Java, chaque objet possède un verrou implicite (moniteur) gérée par la JVM
Pour éviter les problèmes d'accès concurrent, il faut empêcher que  Synchronisation d’un bloc d’instructions
deux threads se retrouvent simultanément dans une section critique. Verrou appliqué sur obj
synchronized (objet){ lorsqu’on invoque
// Aucun autre thread ne  obj.m() (m() méthode sync)
// peut accéder à objet
 ou bien le bloc sync
}
(synchronized (objet) {})
 Synchronisation d’une méthode
Le verrou est libéré :
synchronized void m(){
// Aucun autre thread ne  en quittant la partie
// peut accéder à l’objet synchronisée
// pour lequel est appelé la  en appelant la méthode wait
méthode m
}
46 47

Exemple Synchronisation statique

Une méthode de classe (static) synchronisée (synchronized) applique un
public class Compte { verrou sur toute la classe:
private int solde;
 Quand la ressource partagée appartient à toute les instances d’une classe
public void retirer(int m) { (static) class MyThread1 extends Thread{
Exemple: public void run(){
// tester est ce que le solde est suffisant
class Screen{
if(m <= solde){ [Link](1);
static void printMultiple( }
try {[Link](500);} int n){ }
for(int i=1;i<=10;i++){ class MyThread2 extends Thread{
catch (InterruptedException ie) [Link](n*i) public void run(){
{[Link]();} ;
try{ [Link](10);
solde-=m; [Link](100); }
}catch(Exception e){} }
}else{ } //…
[Link]("Le solde actuel est } class MyThread4 extends Thread{
} public void run(){
de:" + solde);
[Link](1000);
} }
} }

}
48 49
 Synchronisation statique Producteur / consommateur
Une méthode de classe (static) synchronisée (synchronized) applique un Producteurs ont pour mission de déposer des items dans la file
verrou sur toute la classe: Les consommateur les retirent de la file d’attente
 Quand la ressource partagée appartient à toute les instances d’une classe
Si la file est vide le consommateur doit attendre
Si la file est pleine le producteur doit attendre
EM entre t1 et t2

t1 peut interférer Producteur Consommateu

avec t3 1 r1
File d’attente
Objets Producteur Consommateu
partagés 2 r2
I4 I3 I2 I1

EM entre t3 et t4 Producteur Consommateu

P rn

50 51

Coopération entre threads Lock et ReentrantLock

synchronisation coopérative entre threads:
Réaliser des verrous avec les Classes Lock et ReentrantLock (implémentation de
 faire attendre des threads jusqu'à ce qu’une condition soit vérifier
l'interface Lock)
 Réveiller le(s) thread(s) lorsque la condition est vérifiée
 ReentrantLock utiliser des verrous de manière réentrante:
La méthode wait(): Faire attendre le thread (rend la clé du verrou) et attend l’arrivé d’un  Le verrou est obtenu par un thread si aucun autre thread ne le possède ou si le verrou est
signal déjà détenu par le thread lui-même.
notify() / notifyAll(): Réveiller le thread (ou tous les threads) en attente du verrou. Public class Maclass{
private Lock l = new ReentrantLock();
N.B: Ces méthodes doivent être utilisées à l'intérieur d'une méthode ou d'un bloc
public void method(){
synchronized. [Link](); //pauser le verrou (similaire au début d’un
bloc synchronisé)
public class FileFIFO { public synchronized Object retirer() { public synchronized void ajouter(Object o) try {
private int max; while ([Link]() == 0) { { //section critique
LinkedList q ; try while ([Link]() == max) { }
try { [Link]();} finally {
public FileFiFo(int { [Link]();}
catch [Link]();//retiré le verrou(similaire à la fin d’un
max){ catch
(InterruptedException e) { bloc synchronisé)
q= (InterruptedException e) {
} }
new LinkedList(); } }
[Link](o);
return [Link](); }
}
[Link]=max; }
}
52 53
 Verrou et Conditions En résumé
PB1:Un thread a acquis un verrou mais une condition n’est pas rempli. Java propose deux mécanismes de verrouillage Les moniteurs (synchronized)
PB2:Comment placer plusieurs conditions dans le verrou? et les verrous(lock)
Solution: Interface Condition
Les moniteurs :
class Messagerie {
Simples à utiliser,
ReentrantLock verrou = new ReentrantLock();
Condition lecture = [Link](); impossible d’oublier de libérer le verrou : la sémantique du langage le garantit, à la
Condition ecriture = [Link](); sortie du bloc protégé
Condition libre = [Link]();
volatile String envoi = null; volatile boolean occupe = false; un thread en attente d’un moniteur ()est bloqué jusqu’à ce qu’il l’obtienne (pb de
deadlock)
public void envoyer(String message) {
[Link](); // Occupation du canal
while (occupe) { [Link](); } public String recevoir() {
Les verrous :
occupe = true; [Link](); // Attente d'un message + flexibilité d’obtenir ou non un verrou sans que cela soit obligatoirement bloquant
// Envoi while (envoi == null) { [Link](); }
envoi = message; // Réception
[Link](); String message = envoi;
- Pas de déverrouillage automatique (plus de risques d’erreurs)
// Attente de l'accusé // Accusation
while (envoi == message) { [Link](); } envoi = null; [Link]();
// Libération du canal [Link]();
occupe = false; return message;
[Link](); }
[Link]();
}
54 55

Méthodes d’exclusion mutuelle Problèmes de vivacité (liveness)

Les problèmes de synchronisation et d’exclusion mutuelle peuvent être Vivacité: capacité d'une application concurrente à s'exécuter en temps opportun
résolus par plusieurs mécanismes:
Deux problèmes courants de vivacité:
 Verrous
 Famine (starvation):situation dans laquelle un thread ne peut pas progresser vu qu’il n’a pas la
 Événement possibilité d’accéder (régulièrement) aux ressources partagées.
 Sémaphores  Inter-blocage (DeadLock): deux ou plusieurs threads sont bloqués (pour toujours) vu qu’ils
 Moniteurs s’attendent mutuellement.
 Rendez-vous  le principal problème des méthodes dépréciées (stop(), suspend(), resume()), est l'inter-blocage (dead lock)

Thread1 Thread2

Requière
détient
détient

Objet Objet
1 2

56 57
 Exemple Pool d’exécution des Thread
Les threads sont mappés aux threads au niveau du système (ressources du
public class Deadlock { OS).
Object m1 = new Object();  Créer des threads de manière incontrôlable => manquer rapidement de
Object m2 = new Object(); ressources.
 Obtenir un résultat de l'exécution d'un thread
 attendre la fin d'un ensemble de threads
public void ping() { public void pong() {
synchronized (m1) { synchronized (m2) { Solution: Le pattern Thread Pool
 Économiser des ressources dans une application multithread et de contenir le
synchronized synchronized
parallélisme dans certaines limites prédéfinies.
(m2) { (m1) {  planifier l'exécution des tâches et de conserver les tâches entrantes dans une file
// Code synchronisé sur // Code synchronisé sur d'attente.
// les deux moniteurs // les deux moniteurs
} } Séparation entre la tâche et le contexte d’exécution
 Ecrire le code concurrent sous la forme de tâches parallèles et les soumettre
} }
pour exécution à une instance d'un pool de threads.
} }  L’instance contrôle plusieurs threads réutilisés pour l'exécution de ces tâches.

58 59

Executor, ExecutorService ExecutorService

Permettre l’exécution de taches de façon asynchrone.
Exécution concurrente en background (taches runnable)
Package [Link].
 L’interface Executor ne définit qu'une seule méthode :
 void execute(Runnable command) : Exécuter la tâche fournie en paramètre (prochainement)
 deux interfaces filles : ExecutorService, ScheduledExecutorService

L’interface ExecutorService possède plusieurs implémentations:

 ScheduledThreadPoolExecutor, ForkJoinPool (java7)
 Simple méthode: créer une instance ExecutorService est d'utiliser la factory Executors.
 Exemple
ExecutorService executorService = [Link](10);
[Link](new Runnable() {
public void run() {
[Link]("Asynchronous task");
}
});
[Link]();
60 61
Pool de threads ExecutorService, Callable, Future
Méthode l’interface ExecutorService: de nouvelles tâches
Pool de threads: collection de thread initialisés qui vont être utilisables et •execute(Runnable) Interface Callable retourne une valeur de
réutilisables selon les besoins. retour grace à la méthode call():
• Single Thread Executor : un pool qui ne contient qu'un seul thread •submit(Runnable)
• Cached Thread Pool : un pool qui contient plusieurs threads. La taille du •submit(Callable) public interface Callable{
pool varie public Object call() throws Exception;
• Fixed Thread Pool : un pool qui contient un nombre fixe de threads •invokeAny(...) }
• Scheduled Thread Pool : un pool qui contient plusieurs threads pour public interface Runnable {
•invokeAll(...) public void run();
exécuter des tâches planifiées
•shutdown() lorsqu'il n'est plus nécessaire}
Exemple aux threads de l'ExecutorService d'attendre
ExecutorService es1 = [Link](); Future future = [Link](new Callable(){
ExecutorService es2 = [Link](10); public Object call() throws Exception {
[Link]("Asynchronous Callable");
ExecutorService es3 = [Link](10); return "Callable Result";
}
});
[Link]("[Link]() = " + [Link]());
62 63

Introduction
Un S.D. est un ensemble de nœuds sur un réseau qui communiquent entre
eux en échangeant des messages pour coordonner leurs actions afin
d'effectuer un ensemble de tâches.

Communication
Vision Matérielle:
 Machines multi-processeurs avec mémoire partagée
 connectées entre eux (liaison filaire ou sans fil)

via réseau
 Via un réseau (typologie (LAN, MAN, WAN), topologie (Bus, Etoile, anneau, etc.))

CHAPITRE 3

64 65
 Introduction Rappel sur les réseaux
Vision logicielle: Système ouvert: système désirant échanger des données avec un autre
 Ensemble d’entités logiciels s’exécutant indépendamment et en parallèle sur des
Norme OSI (Open System Interconnection) de l'ISO : architecture en 7
machines
 On parlera de processus (programme en cours d’exécution) plutôt que de logiciel. couches Dialogue
 Ces processus communiquent entre eux via des canaux de communication Programme A Programme B

La Communication est un point crucial

Processus Processus
A B

CANAL

66 67

Rappel sur les réseaux Rappel sur les réseau

 Norme OSI de l'ISO : architecture en 7 couches 
Application : protocoles applicatifs (transfert de fichiers, messagerie, pages web, etc.)

Présentation : représentation des données (entiers, chaînes de caractères...) et leurs

codage/décodage

Session : synchronisation et la gestion (ouverture/ fermeture) d’une connexion entre

applications,.

Transport : fournir une communication de bout en bout entre 2 applications (TCP/UDP)

Réseau : construction des paquets, trouver les routes à travers un réseau pour atteindre la
machine destinataire (IP adresse)

Liaison : assemblage des blocs de données (trames) et gestion d'accès au support physique,
assure que les données envoyées sur le support physique sont bien reçues par le destinataire

Physique : transmission/réception des données binaires sur un support physique (radio, )

68 69
 Rappel sur les réseaux Architecture Client / Serveur (Rappel)

Architecture très populaire dans les systèmes distribués et

Modèle TCP/IP: le plus utilisé en pratique (Internet) convient à une grande variété d’applications
Couche réseau : IP (Internet Protocol) Deux composants majeurs qui interagissent via un réseau
 Définition de l'adressage  Serveur: un composant (processus) implémentant un service
 Recherche des routes à travers le réseau pour acheminer les message vers leur spécifique (ex: fichiers, base de données).
destination prévue.  Client: Composant qui demande un service à un serveur en lui
envoyant une demande et en attendant la réponse du serveur.
Couche transport (TCP/UDP)
 TCP : connexion virtuelle directe (fiable) entre 2 machines. Scénario basique:
 UDP : mode datagramme (non fiable) 1. Serveur: en attente d’une requête ; Client Serveur
 Envoi de paquets de données 2. Client: envoie une requête au serveur et attend une réponse 1
 Pas de gestion de l'ordre d'arrivée, pas de gestion des paquets perdus
3. Serveur: Apres réception d’une requête, il la traite et envoie une 2.1
3.1

réponse
4. Client: reçoit la réponse du serveur 2.2 3.2

 Architecture P2P???? 4
3.3

70 71

Modèle TCP/IP Adresse d’une application

Modèle TCP/IP est le plus répandu Comment identifier (communiquer) une application dans un réseau ?
Les applications (client et serveur) désirant réaliser une communication réseau Adresse « réseau » application: couple de 2 informations
doivent faire appel au services offerts par la couche transport  Adresse IP : identifiant de la machine sur laquelle tourne l'application App App App
 Numéro de port : identifiant local réseau de l'application
Port
Requête Requête
Couche réseau : adresse IP
Application Processus Réseau Processus  Exemple : [Link]
Client Serveur Couche Transport(TCP/UDP)
Couche transport : numéro de port (TCP ou UDP)
Réponse Réponse
Transport  Entier codé sur 16 bits (65 536)
Couche Réseau (IP)
(TCP,UDP,…)  Sur un port : réception ou envoi de données
TCP Transmission control UDP: User Datagram Protocol  Ports < 1024 : réservés pour les applications ou protocoles systèmes
Protocol  Protocole Peu Fiable (poste) (Ex : 80 = HTTP, 21 = FTP, ...)
Internet(IP,..)  Protocole fiable (téléphonie)  Emission multicast/Broadcast Adresse notée : IP:port
 Point à point  Rapide (perte occasionnelle d'un  Ex: [Link]:80 : accès au serveur Web tournant sur la machine
 Lent (gestion de flux) paquet est tolérable) d'adresse IP [Link]
Link(IP,..)  Applications: HTTP, FTP, SMTP  Applications: Streaming, VOIP

72 73
Adresse d’une application Les Sockets
Une socket (Prise) est le point de communication par lequel un processus peut
émettre/recevoir des données à travers le réseau.
A chaque socket est associé un port local
Permet la communication avec une application distante (port distant sur une machine
distante)

Processus Emetteur Processus Récepteur

Port Port
Socket Socket

Couche Transport(TCP/UDP) Couche Transport(TCP/UDP)

Couches inférieures Couches inférieures

Canal de communication
74 75

Client/serveur avec Sockets

Architecture Client/serveur impose deux rôles différents:
 le client (demandeur de service) et le serveur (fournisseur de service)
 Possibilité que les processus communiquant jouent un autre rôle ou bien les 2 en même
temps
Différenciation pour plusieurs raisons:
 Identification : on doit connaître précisément la localisation du serveur
 Le serveur communique via une socket liée à un port précis : port d'écoute

Flux d’entrée/sortie
 L'adresse du serveur (@IP et port) est connue du client
 Dissymétrie de la communication/connexion
 Le client initie la connexion ou la communication

Processus Client Processus Serveur

Socket Port Port
Socket

Couche Transport(TCP/UDP) Couche Transport(TCP/UDP)

Couches inférieures Flux E/S Couches inférieures

Canal de communication
76 77
Flux d’entrée/Sortie Flux de caractères
Un Processus (Programme en cours d’exécution) a besoin d'échanger des données: Java gèrent les caractères avec le format Unicode (2 octets)
 Recevoir des données d'une source
Deux classes de base (abstraites) Reader ou Writer.
 Envoyer des données vers un destinataire
De nombreuses sous-classes pour traiter les flux de caractères
En java, les entrées sorties sont gérés par des objets de Flux permettant d'encapsuler les
processus d'envoi et de réception (package [Link])
 Préfixe représenter des flux ou bien des filtres:
les flux peuvent être divisés en deux catégories :
 Flux: le préfixe contient la source ou la
 les flux manipulant des caractères (reader/writer)
Flux (E/S) destination du flux
 Les flux manipulant d'octets (in/out)  Filtres: le préfixe contient le type de traitement
qu'il effectue
Flux de  Préfixe Buffered: Améliorer les performances avec
Flux d’octets la mise en tampon des données (lues ou écrites)
caractères
BufferedReader fichier =
new BufferedReader(
new FileReader(“[Link]"));
InputStream OutputStream Reader Writer

78 79

Flux de caractères (Classe Reader) Exemple flux de caractères (Lecture)

Méthodes Rôles public class TestBufferedReader {

private String source;
boolean markSupported() indique si le flux supporte la possibilité de marquer des positions
public TestBufferedReader(String source) {
boolean ready() indique si le flux est prêt à être lu [Link] = source;
close() ferme le flux et libère les ressources qui lui étaient associées lecture();
}
int read() renvoie le caractère lu ou -1 si la fin du flux est atteinte. public static void main(String args[]) {
int read(char[]) lire plusieurs caractères et les mettre dans un tableau de caractères new TestBufferedReader("[Link]");
}
int read(char[], int, lire plusieurs caractères. Elle attend en paramètre : un tableau de
caractères qui contiendra les caractères lus, l'indice du premier élément private void lecture() {
int)
du tableau qui try {
String ligne ;
long skip(long) saute autant de caractères dans le flux que la valeur fournie en BufferedReader fichier = new
paramètre. BufferedReader(new FileReader(source));
Elle renvoie le nombre de caractères sautés.
while ((ligne = [Link]()) != null) {
mark() permet de marquer une position dans le flux [Link](ligne);
reset() retourne dans le flux à la dernière position marquée }
[Link]();
} catch (Exception e) {
[Link]();
}
}
}

80 81
 Flux de caractères (Classe Writer) Exemple flux de caractères (Ecriture)
public class TestPrintWriter {
private String destination;
public TestPrintWriter(String destination) {
Méthodes Rôles [Link] = destination;
ecriture();
close() Ferme le flux et libère les ressources qui lui étaient associées }
public static void main(String args[]) {
write(int) Ecrire le caractère en paramètre dans le flux. new TestPrintWriter("[Link]");
}
write(char[]) Ecrire le tableau de caractères en paramètre dans le flux. private void ecriture() {
try {
String ligne ;
write(char[], int, int) Ecrire plusieurs caractères. Elle attend en paramètres : un tableau de
caractères, l'indice du premier caractère et le nombre de caractères à String data = "systemes distribués";
écrire. PrintWriter fichier = new PrintWriter(new
FileWriter(destination));
write(String) Ecrire la chaîne de caractères en paramètre dans le flux [Link]("bonjour tout le monde");
[Link]("Nous sommes le "+ new
write(String, int, int) Ecrire une portion d'une chaîne de caractères. Elle attend en paramètre : Date());
une chaîne de caractères, l'indice du premier caractère et le nombre de [Link]("intitulé du module est:
caractères à écrire. " + data);
[Link]();
} catch (Exception e) {
[Link]();
}
}
}
82 83

Flux d'octets (écriture sur un

Flux d’octets fichier)

Les classes qui gèrent les flux d'octets héritent d'une des deux classes
abstraites InputStream ou OutputStream.
Méthodes Rôles
 Il existe de nombreuses sous-classes pour traiter les flux d'octets
close() Ferme le flux et libère les ressources qui lui étaient associées

write(int) Ecrire l’octet en paramètre dans le flux.

write(byte[]) Ecrire le tableau d’octets à écrire en paramètre dans le flux.

write(byte[], int, Ecrire plusieurs octets. En paramètres : un tableau d’octets

int) contenant les octets à écrire, l'indice du premier et le nombre
d’octets à écrire.

84 85
flux d'octets (Lecture sur un fichier) Exemple flux d’octets (L/E sur fichier)
public class FileUtilitiesFichier {
public static void copierfichierOctets(String source, String dest)throws
IOException{
FileInputStream in = null;
FileOutputStream out = null;
Méthodes Rôles
try {
in = new FileInputStream(source);
close() Ferme le flux et libère les ressources qui lui étaient out = new FileOutputStream(dest);
associées int c; //byte buffer[] = new byte[1024];
int read() envoie la valeur de l'octet lu ou -1 si la fin du flux est while ((c = [Link]()) != -1) //(c = [Link](buffer)) !=
atteinte. -1
[Link](c); //[Link](buffer, 0, c);
int read(byte[], lit plusieurs octets. En paramètre : un tableau }
int, int) d'octets qui contiendra les octets lus, l'indice qui finally {
recevra le premier octet et le nombre d'octets à lire if (in != null) [Link]();
if (out != null) [Link]();
int available() retourne une estimation du nombre d'octets qu'il }
est encore possible de lire dans le flux }

public static void main(String[] args) {

try {
copierfichierOctets("[Link]", "[Link]");
} catch (IOException e) {
[Link]();
}
}
86 } 87

Principe de fonctionnement
TCP fonctionne en mode connecté (point à point):

1)Le Serveur enregistre son Service sur un port et se met sous écoute à l’aide d’une Socket Serveur

2)Le client crée une socket (port dynamique) puis demande d’ouvrir une connexion avec le serveur
(@IP:port) sur sa socket Serveur d'écoute

3)Du coté du serveur, le service d'attente de connexion retourne une socket de service (Par client)

Sockets TCP
4)le client et le serveur communiquent en envoyant et recevant des données via leurs sockets (I/O)
Client Serveur @IP:[Link]
Création SocketServeur sur un port précis (7654)
Attente d’une connexion réserve
Création de la socket
Un port local est dynamiquement
assigné Demande de connexion un port temporaire
automatiquement local
(4545) à chaque client
Création d’une socket de service (client)
(19529)

Entrée Sortie
Communication avec le client via cette socket
Communication avec le serveur
Sortie Entrée
88 89
 Sockets TCP en Java InetAdress Exemple
public class InetAdressDemo{
Classes du package [Link] utilisées pour communication via TCP
public static void main(String[] args){
InetAddress adr;
Socket ServerSocket InetAdress try {

Socket(String host, int port) ServerSocket(int port) InetAddress getByName(String host) adr = [Link]("[Link]");
InetAddress getLocalHost()
Static
• Socket accept()
 InputStream getInputStream() [Link]("Host Name: "+[Link]());
renvoie la socket et  String getHostName()
 OutputStream getOutputStream() établit une connexion
renvoie le nom d'hôte de l'adresse [Link]("IP Address: "+[Link]());
Retourne le flux d’entrée/sortie (C/S).
attaché à cette socket IP.
• void close()  String getHostAddress() } catch (UnknownHostException e) {
 void close() Ferme la socket serveur
Ferme la socket client renvoie l’adresse IP du hôte. [Link]();
}
ServerSocket ss=new }
ServerSocket(7654);
Socket s=[Link]();

90 91

Interfaces de connexions réseau Socket Côté client

NetworkInterface classe qui encapsule les interfaces de connexions aux réseaux
1. Créer une socket
(cartes) et qui permet d'obtenir la liste des interfaces de connexions de la machine.
Socket client = new Socket(server, port_id);
Chaque interface (carte réseau) peut disposer de plusieurs adresses
public class TestNetworkInterface { 2. Créer les flux d’E/S pour la communication
public static void main(String[] args) {
try { Scanner in = new Scanner([Link]());
[Link]();
} catch (Exception e) {[Link]();}
PrintWriter out = new
} PrintWriter([Link](),true);
private static void getLocalNetworkInterface() throws Exception {
Enumeration interfaces = [Link](); 3. Communiquer avec le serveur
while ([Link]()) {
NetworkInterface ni; [Link](“Message envoyé au serveur… \n”); // envoyer
Enumeration<InetAddress> adresses;
ni = (NetworkInterface) [Link]();
message
[Link]("Network interface : "); Processusles
[Link]() // recevoir Client
données du serveur
[Link](" nom court = " + [Link]());
[Link](" désignation = " + [Link]());
adresses = [Link]();
4. Fermer la socket
while ([Link]()) { [Link](); OutputStream
InetAddress ia = (InetAddress) [Link]();
Port 7654
[Link](" adresse I.P. = " + ia); InputStream
}
}
}
}
92 93
 Socket Côté Serveur Exercice
1. Créer une socket serveur // port d’écoute port_id
ServerSocket server = new ServerSocket(port_id);
Ecrire un programme (client/Serveur) qui permet d’envoyer
2. Répéter la date à un client qui demande de communiquer avec le
1. Attendre une connexion avec un client serveur.
Socket s_com_client = [Link]();
Public void traitement( socket s){
BufferedReader in = new BufferedReader(
2. Traitement la connexion new
InputStreamReader([Link]()));
// faire appel au traitement PrintWriter out = new
traitement(s_com_client) PrintWriter([Link](),true);
//Communiquer avec le client
[Link](“Message envoyé au client… \n”);
4. Fermer la socket serveur [Link]() // recevoir les données du serveur
[Link](); //Fermer la socket de traitement avec le client
[Link]();
}

Processus Client Processus serveur

Port 9654
Port 7654 OutputStream
OutputStream
InputStream InputStream
94 95

Servir plusieurs clients Servir plusieurs Clients

Application client/serveur classique
Solution (Multithreading)
 Un serveur et Plusieurs clients (indépendants les un des autres et en parallèle)
Un processus en attente de connexion sur le port d'écoute
Le serveur doit pouvoir répondre aux requêtes des clients sans contrainte sur Nouvelle connexion : un nouveau processus à créer pour gérer la communication avec le
l'ordre d'arrivée des requêtes nouveau client

Problèmes

Le serveur est bloqué jusqu’à ce qu’un client se

connecte au serveur :

Socket s = [Link]();
Le serveur et le client seront bloqués si les
donnée à partir de la socket ne sont pas
disponibles(lecture/écriture)
String line = [Link]();

96 97
 Socket Côté Serveur (MultiThread)
1. Créer une socket serveur // port d’écoute port_id
ServerSocket server = new ServerSocket(port_id);
2. Répéter
i. Attendre une connexion avec un client public class ClientJob extends Thread {
Socket s_com_client = [Link](); private Socket socket;
public ClientJob(Socket socket) {
[Link] = socket;
ii. Traitement sur la connexion

Socket UDP
}

// créer un thread pour le nouveau client

ClientJob clientHandler= new ClientHandler(s_com_client);
Public void traitement( socket s){
[Link] (); Scanner in = new Scanner([Link]());
PrintWriter out;
4. Fermer la socket serveur out = new PrintWriter([Link](),true);
//Communiquer avec le client
[Link]();
[Link](“Message envoyé au client… \n”);
[Link]() // recevoir les données du serveur
//Fermer la socket de traitement avec le client
[Link]();
}
Public void run( ){
traitement(socket);
}
}
98 99

Socket UDP: Principe Principe de fonctionnement

UDP fonctionne en mode non connecté :
UDP est un protocole basé sur IP qui permet une connexion de type point à point ou
de type multipoint. 1. Le Serveur crée une socket sur un port précis
Mode datagramme (non connecté) : Envois de paquets de données (datagrammes) 2. Le serveur se met en attente de réception d’un paquet
3. Le client crée une socket (port dynamique) pour accéder à la couche UDP
Pas de fiabilité ou de gestion de la communication:
4. Le client envoie un paquet via sa socket en précisant l'adresse du destinataire (@IP:port
 Perte de paquet (sans que l'émetteur en soit informé)
du serveur)
 L’ordre des paquets n’est pas garantie (routage réseau)  L'adresse du client (@IP et port) est précisée dans le paquet, le serveur peut alors lui répondre
 Paquets détruits si le destinataire n’est pas sur écoute (sans informer l'émetteur)
Client Serveur @IP:[Link]
Caractéristiques des primitives de communication:
Création SocketServeur sur un port précis (7654)
 Émission de paquets est non bloquante
 Réception de paquets est bloquante Attente d’un Paquet
P1 P2 Création de la socket
P2 P1
Envoie de Paquet
Emetteur Destinataire
Réception non garantie,
Réception d’un paquet l’ordre non plus
Traitement
Réception non garantie, Envoi d’un paquet à l’émetteur
Mode non connecté l’ordre non plus Réception avec le serveur

100 101
 Socket UDP en Java Socket Côté client
Java intègre nativement les fonctionnalités de communication réseau :Package [Link]
1. Encapsuler l’adresse du serveur dans un objet InetAddress
Classes utilisées pour communication via UDP
 InetAddress : codage des adresses IP InetAddress adr = [Link]("[Link]");
 DatagramSocket : socket mode non connecté (UDP)
2. Spécifier les données à envoyer
 DatagramPacket : paquet de données envoyé via une socket sans connexion (UDP) byte[] sendData = (new String(“message envoyé au serveur")).getBytes();
3. Créer un paquet avec les données et en précisant l'adresse du serveur
DatagramPacket DatagramSocket
InetAdress DatagramPacket packet = new DatagramPacket(sendData, [Link], adr, 7676);
DatagramPacket(byte[] buf, int length, InetAddress address, DatagramSocket(int port)
int port)
DatagramSocket() InetAddress getByName(String host) 4. Créer d'une socket sans la lier à un port particulier (allocation dynamique)
DatagramPacket(byte[] buf, int length) InetAddress getLocalHost() Static
socket = new DatagramSocket();
• void send(DatagramPacket p) Processus Client
 InetAddress getAddress() Si paquet à envoyer :  String getHostName()
Envoie le paquet au destinataire 5. Envoyer le paquet via la socket
adresse du destinataire renvoie le nom d'hôte de
spécifié dedans (@IP/port) .
Si paquet reçu : adresse de l’émetteur • void receive(DatagramPacket p) l'adresse IP. [Link](packet);
send
 int getPort() Retourne le port enregistré dans le Reçoit un paquet. Les données  String getHostAddress()
paquet(Emetteur ou destinataire) reçues seront placées dans P (data, receive
renvoie l’adresse IP du hôte. 6. Fermer la socket
 byte[] getData() Données contenues dans le paquet adresse émetteur)
• int getLocalPort() Retourne le port [Link]()
 Int getLength() retourne la longueur des données local de lié à la socket
(envoyées/reçues) • void close() Ferme la socket
LES SETTERS AUSSI!!!
102 103

Socket Côté Serveur Socket côté serveur (suite)

1. Créer la socket serveur liée au port 7676 La communication se fait souvent dans les 2 sens
 Le serveur connaît la localisation du client à travers son paquet qu’il a reçu.
DatagramSocket socket = new DatagramSocket(7676);
2. Créer le tableau qui va recevoir les données Réponse au client, coté serveur

byte[] data = new byte[50]; [Link](" paquet reçu de : "+ [Link]()+":"+

[Link]());
3. Créer un paquet en utilisant le tableau d’octets (encore vide)
Mettre la donnée à envoyer dans le paquet (contient déjà le couple @IP/port du
DatagramPacket packet = new DatagramPacket(data, [Link]); client)
5. Attendre la réception d’un paquet. Le paquet reçu est placé dans l’objet packet et les données
dans data
String reponse = "bien recu";

[Link](packet); [Link]([Link]());
Processus Serveur
6. Récupérer (et afficher) les données [Link]([Link]());
7676 send Envoyer le paquet au client
String s = new String([Link](), 0, [Link]());
[Link](" Message reçu du client: "+s); receive [Link](packet);

104 105
Résumé
Socket UDP
Simple à programmer
Pas fiable
Ne permet d'envoyer que des tableaux de byte

Multicast UDP/IP
 les Langages de programmation de haut niveau manipulent des objets

106 107

Introduction Multicast
Adresse IP multicast
Communiquer des applications 1 à 1 via des sockets UDP ou TCP  Classe d'adresse IP entre [Link] et [Link]
Comment réaliser une communication 1 à plusieurs?  Classe D
 Adresses entre [Link] et [Link] sont utilisables par un programme quelconque
UDP offre un autre mode de communication : multicast  Les autres sont réservées
 Plusieurs récepteurs pour une seule émission d'un paquet  Une adresse IP multicast n'identifie pas une machine sur un réseau mais un groupe multicast
Broadcast, multicast
 Broadcast (diffusion) : envoi de données à tous les éléments d'un réseau
 Multicast : envoi de données à un sous-groupe de tous les éléments d'un réseau

 Multicast IP
 Envoi d'un datagramme sur une adresse IP particulière
 Plusieurs éléments lisent à cette adresse IP

108 109
 Multicast Multicast
Adresse IP multicast
 Classe d'adresse IP entre [Link] et [Link] Utilités du multicast UDP/IP
 Classe D  Évite d'avoir à créer X connexions et/ou d'envoyer X fois la même
 Adresses entre [Link] et [Link] sont utilisables par un
programme quelconque
donnée à X machines différentes
 Les autres sont réservées  Utilisé pour diffuser des informations
 Une adresse IP multicast n'identifie pas une machine sur un
réseau mais un groupe multicast
 Diffusion de flux vidéos à plusieurs récepteurs
 Chaîne de télévision, diffusion d'une conférence
Socket UDP multicast
 Le même flux est envoyé à tous au même moment
 Avant envoi de paquet : on doit rejoindre un groupe
 Identifié par un couple : @IP multicast/numéro port  Pour récupérer des informations sur le réseau
 Un paquet envoyé par un membre du groupe est reçu par tous les membres
 [Link] : pour localiser un serveur DHCP
de ce groupe
Limites
 Non fiable et non connecté (comme UDP)

110 111

Multicast UDP en Java Multicast UDP (exemple)

adresse IP multicast du groupe
DatagramSocket
Classe [Link] InetAddress group = [Link]("[Link]");

Constructeurs : identiques à ceux de DatagramSocket  socket UDP multicast pour communiquer avec groupe [Link]:4000

MulticastSocket socket = new MulticastSocket(4000);

 public MulticastSocket() Crée une nouvelle socket en la liant à MulticastSocket
un port
 données à envoyer
quelconque libre
byte[] data = (new String("youpi")).getBytes();
 public MulticastSocket(int port) Crée une nouvelle socket en la liant au port
 paquet à envoyer (en précisant le couple @IP/port du groupe)
précisé (c'est le port qui identifie le groupe de multicast)
DatagramPacket packet = new DatagramPacket(data, [Link], group, 4000);
Gestion des groupes  on joint le groupe

 public void joinGroup(InetAddress mcastaddr) : Rejoint le groupe dont [Link](group);

l'adresse IP multicast est passée en paramètre  on envoie le paquet

[Link](packet);
 public void leaveGroup(InetAddress mcastaddr) : Quitte un groupe de
 attend un paquet en réponse
multicast
[Link](packet);

 traite le résultat et quitte le groupe

[Link](group);

112 113
 Introduction
Sur une même machine
 Interaction entre composants software: Un composant pourra demandé un service d’un
autre composant.
 Appel à une fonction/ procédure. En local
 En POO appel à une méthode:

Appel distant (Sockets TCP & UDP) a : Classe A « use » b : Classe B

Public void
 Communication par envoi et réception de bloc de données

RMI
[Link](); methode()
 Communication bas niveau qu'appel de fonction

Contraintes des systèmes distribuées:

 Les différents objets ne s'exécutent pas dans les mêmes JVM ni sur les mêmes machines.

Comment réaliser un tel appel pour une méthode qui se trouve à distance???
CHAPITRE 3 (SUITE)
Machine A Machine B
« use » b : Classe B
a : Classe A Public void
[Link](); methode()

115
114

Objectif Middleware
Idée générale:
 Invoquer une méthode d’un objet distant de façon simple voire identique à un appel local.
Middleware (intergiciel en fr) : couche logiciel
Principes
 On différencie le coté appelant (client) du coté appelé (serveur) Situer entre le système d'exploitation/réseau et les éléments de l'application
 Le serveur offre la possibilité à des éléments distants d'appeler une ou plusieurs distribuée
méthodes qu’il hébérge. Offre un ou plusieurs services de communication entre les éléments formant
 Le côté client appelle localement la fonction sur un élément spécial (Talon) qui relayera la l'application ou le système distribué
demande d'appel de fonction coté serveur
 Dans le Côté serveur, un élément spécial (Squelette) appellera la fonction et renverra le Services de plus haut niveau que les communications via sockets TCP/UDP,
résultat au client augmentation du niveau d'abstraction
 Middleware!!!!!

116 117
 Familles de Middleware Familles de middlewares
Plusieurs Solutions  caractéristiques générales

Appel de procédure/méthode à distance Modèle RPC/RMI

 RPC : appel de procédure distante  Interaction forte entre parties client et serveur
  Appel synchrone (pour le client) d'opération sur le serveur
RMI : mono langage, multi plateforme
 Généralement, le client doit explicitement connaître le serveur
 CORBA : multi langage, multi plateforme  Peu dynamique (point de vue serveur) car les éléments serveurs doivent être connus par les clients et lancés avant
 COM : multi langage, mono plateforme (multi pour DCOM) eux
 Web services : multi langage, multi plateforme  Mode POINT à POINT : opération appelée sur un seul serveur à la fois

Envoi ou diffusion de messages ou événements Modèles à diffusion de messages ou mémoire partagée

 Famille des MOM (Message Oriented Middleware)  Asynchrone et pas d'interaction forte entre éléments
 Envoi de message est asynchrone
 Event Service de CORBA, JMS de Java
 Pas de nécessité de connaître les éléments accédant à la mémoire

Mémoire partagée  Permet une plus forte dynamicité : ajout (et départ) d'éléments connectés au middleware faciliter par les faibles
interactions et l'anonymat
 Accès à une mémoire commune distribuée  Mode 1 à plusieurs
 JavaSpace de Java  Diffusion de messages à plusieurs éléments en même temps
 Accès aux informations de la mémoire par plusieurs éléments

118 119

Fonctionnement général RPC/RMI Remote Procedure Call

1. Le client récupère via le service de nommage une référence Fonctionnement d’un appel de fonction distante
d'objet sur le serveur

2. Le client appelle une opération sur cette référence d'objet

(appel synchrone)

3. Le talon (Stub/Proxy) reçoit cet appel, « compacte » (marshall)

toutes les données relatives à l'appel (identification opération +
paramètres)

4. Le Stub (client) envoie les données au Skeleton (serveur)

5. Le squelette décompacte les données (unmarshall) pour

déterminer l'opération à appeler sur le Serveur élément/proxy qui
offre localement les
6. L'opération est appelée sur le Serveur par le squelette
mêmes opérations (la
Service de élément qui reçoit les
7. Le squelette récupère la valeur de retour de l'opération, la même interface) que
compacte et l'envoie au talon nommage requêtes d'appels
le Serveur
(annuaire) d'opérations des
8. Le talon décompacte la valeur et retourne la valeur au client
clients et les lance sur
9. L'appel de l'opération distante est terminé, le client continue Limitations
son exécution
le servant
 Absence de concepts orienté objets (classe, interface, objet, polymorphisme, etc.)

120 121
 RMI Principe générale
Package [Link] : classes/interfaces à utiliser pour établir des communications via RMI
Solution java intégré au JDK (depuis la version 1.1) Règles principales à suivre
 Une version "orientée objet" de RPC  Une interface de méthodes appelables à distance doit spécialiser l'interface [Link]
 Transparent : Permet aux Objets Java Distants de communiquer sans écrire une ligne de  Toute méthode de cette interface doit préciser dans sa signature qu'elle peut lever l'exception
code réseau RemoteException
 Simple: Lorsque les objets communicants sont implémentés en Java, la communication est  Le serveur implémente une (ou plusieurs) interface(s) spécialisant Remote et doit spécialiser (ou utiliser
plus simple que d’autres solutions (CORBA par exemple). des services de) UnicastRemoteObject
Caractéristiques de RMI  Les classes des données en paramètres ou retour des méthodes doivent implémenter Serializable
 Communication basée sur les sockets
 Codage des échanges via un protocole propriétaire
RMP (Remote Method Protocol) Côté Client Côté Serveur
L’accès aux méthodes distantes se fait via cet interface
« interface » Remote

IRemote
« interface »IRemote
Objet getOperation1( params) throws RemoteExeception
« use » Objet getOperation2( params) throws RemoteExeception UnicastRemoteObject
Client
Iremote r;
r.getOperation1(para
ImpInterfaceRemote
m),
122 123

Etapes de développement Exemple(côté serveur)

Côté serveur:
1. Une interface qui contient les méthodes appelables à distance Accéder à distance à des données relatives aux comptes d’une banques
 doit implémenter l'interface [Link]
 Toute méthode de cette interface doit préciser dans sa signature qu'elle peut lever l'exception public interface IRemoteBanque extends Remote {
RemoteException public int getSolde(int i) throws
RemoteException; public class RemoteBanque extends UnicastRemoteObject implements
 Les classes des attributs en paramètres ou de retour des méthodes doivent être Serializable (pour transiter public String getProprietaire(int i) IRemoteBanque {
via des sockets) throws RemoteException; private ArrayList<Compte> comptes;
} public RemoteBanque() throws RemoteException {
2. Classe qui implémente cette interface super();
public class MainServer { comptes= new ArrayList<Compte>();
 doit étendre la classe UnicastRemoteObject
}
3. Une classe qui instanciera l’objet et l’enregistrera en lui affectant un nom dans le public static void main(String[] args) { @Override
try { public int getSolde(int i) throws RemoteException {
registre de noms RMI (RMI registry) RemoteBanque b= new RemoteBanque(); return [Link](i).getSolde();
// ajouter des comptes… }
Identifier les interfaces dont les méthodes // démarrer le registre de noms RMI sur le port 1099
Côté Client Côté Serveur peuvent être appelées à partir d'une [Link](1099); @Override
« interface » Remote machine virtuelle distante // Enregistre l’objet b sous le nom banque, en public String getProprietaire(int i) throws RemoteException{
L’accès aux méthodes distantes se fait via cet interface //écrasant la précédente liaison b/banque si elle return [Link](i).getNom();
Exporter l'objet pour le rendre //existait }
disponible pour recevoir des appels [Link]("rmi://localhost:1099/ public void addCompte(Compte c){
IRemote banque", b); [Link](c);
« interface »IRemote entrants RMP
[Link](" le serveur est pret à }
Objet getOperation1( params) throws RemoteExeception public void removeCompte(int i){
recevoir des demandes...");
« use » Objet getOperation2( params) throws RemoteExeception UnicastRemoteObject } catch (Exception e) { [Link](i);
[Link](); }
Client } }
Iremote r; }
r.getOperation1(param), ImpInterfaceRemote }

124 125
 Registre de noms (Démarrage) Registre de noms
Ligne de commande Classe [Link] offre des méthodes statiques pour enregistrer des objets et
récupérer leurs références
 Unix/Linux : $ rmiregistry [port]
void bind(String name, Remote obj)
 Windows : > start rmiregistry [port]
 Enregistre un objet sous le nom name (erreur si déjà un objet avec ce nom)
 Le port d’écoute par défaut est 1099
void rebind(String name, Remote obj)
Objet Java qui peut lancer un registry  Enregistre un objet sous le nom name, en écrasant la précédente liaison objet/nom si elle existait

 La classe [Link] est utilisée pour faire fonctionner un void unbind(String name)
registre sur le hôte local.  Supprime du registry la référence vers l'objet nommé name
 public static Registry createRegistry(int port) throws RemoteException String[] list(String name)
 Exemple: [Link](1099);  Retourne l'ensemble des noms des objets enregistrés sur le registry

Remote lookup(String name)

 Retourne une référence sur l'objet dont le nom est passé en paramètre

N.B l’attribut name dans les 5 méthodes est sous la forme URL de type RMI
(rmi://hote:port/nomObj )

126 127

Etapes de développement Exemple (côté client)

Côté Client: Les parties client se connectent au serveur pour accéder aux données
1. La même interface qui contient les méthodes appelables à distance
public class MainClient {
2. Obtenir une référence sur l'objet distant à partir de son nom
 Classe Naming via sa méthode statique lookup et l’url de l’objet distant (rmi://hote:port/nomObj)
public static void main(String[] args) {
3. L'appel à la méthode à partir de cette référence // TODO Auto-generated method stub
try {
IRemoteBanque
Identifier les interfaces dont les banque=(IRemoteBanque)[Link]("rmi://localhost:1099/ba
Côté Client Côté Serveur méthodes peuvent être appelées à nque");
« interface » Remote partir d'une machine virtuelle distante
L’accès aux méthodes distantes se fait via cet interface String s=[Link](0);
« interface »IRemote Exporter l'objet pour le rendre
[Link](" le nom du client est:"+s);
IRemote
Objet getOperation1( params) throws disponible pour recevoir des [Link]("le solde actuel
RemoteExeception appels entrants RMP
« use » Objet getOperation2( params) throws UnicastRemoteObject est :"+[Link](0));
RemoteExeception } catch (Exception e) {
Client
Iremote r; // TODO Auto-generated catch block
r.getOperation1(para
ImpInterfaceRemote
[Link]();
m), }

128 } 129

}
 Stub et Skeleton Gestion de sécurité
Générer les classes stub et skeleton à base du fichier de l'objet distant A chaque fois qu’un programme charge du code à partir d’une autre machine
sur le réseau, le problème de la sécurité se pose
JDK 1.2 (ligne de commande)
 rmic –v1.2 BanqueRemote utiliser un gestionnaire de sécurité dans les applications clientes RMI
 Deux fichiers sont générés  [Link]
 Fichier stub  [Link](RMISecurityManager)
 BanqueRemote_Skel.class
Par défaut, RMISecurityManager empêche tout le code dans le
programme d'établir des connexions réseau.
Skelet
Stub on Nécessité d’avoir une permission pour atteindre le RMI Registry, les objets
distants, etc.
JDK 5.0:
 Toutes les classes stub sont générées automatiquement
Solution: Mise en place d’une politique de sécurité (client ou serveur) via «policy
file»: [Link]
 La classe skeleton n’est plus nécessaire à partir de JDK1.2
grant{
permission [Link] "localhost:1099",
"connect, resolve, accept, listen";
}
Documentation en ligne
130 131

grant{
permission [Link]
"*:1024-", "connect, accept, listen";

Exemple(côté serveur) }
Exemple (côté client)
Accéder à distance à des données relatives aux comptes d’une banques Les parties client se connectent au serveur pour accéder aux données
public class MainServer { public class MainClient {
public static void main(String[] args) {
try { public static void main(String[] args) {
// TODO Auto-generated method stub
[Link]("[Link]","[Link]
");
try {
[Link](new
SecurityManager()); [Link]("[Link]","[Link]");
[Link](new
RemoteBanque b= new RemoteBanque();
// ajouter des comptes… SecurityManager());
// démarrer le registre de noms RMI IRemoteBanque
sur le port 1099 banque=(IRemoteBanque)[Link]("rmi://localhost:1099/ba
[Link](1099); Autorise l’application à écouter,
nque");
// Enregistre l’objet b sous le nom banque, en accepter et établir des connections
écrasant //la précédente liaison b/banque si réseau sur un port supérieur à 1024 String s=[Link](0);
Autorise l’application à établir des
elle existait sur le l’hôte local. [Link](" le nom du client est:"+s);
connections réseau au port 1099 sur
[Link]("rmi://localhost:1099/banque", [Link]("le solde actuel l’hôte local (machine contenant le
b);
[Link](" le serveur est pret à est :"+[Link](0)); registry).
grant{
recevoir des demandes..."); } catch (Exception e) {
} catch (Exception e) {
permission [Link] "localhost:1099",
132 // TODO "connect";
Auto-generated catch block 133
[Link]();
}
[Link]();
}
}
Résumé
Dans un programme Java
Obj
 Les Objets possèdent des références les uns sur les autres Obj
2
1
 Ils peuvent appeler des méthodes sur les objets dont ils ont les références
 Les paramètres et valeur de retour des méthodes peuvent être des références Obj
d'objet 3
JVM Local
Java RMI

Coordination
 Un objet « distribué » accessible à distance
 Le but est détendre le concept de référence d'objet à des objets physiquement
distants (dans une autre JVM)
 Pouvoir appeler les méthodes de l’objet distant comme en local

Obj
CHAPITRE 4
Obj
Obj D
2
1

Obj
3
JVM Distant
JVM Local

134 135

Algorithmes de
synchronisation
Problèmes spécifique au contexte distribué Dans un contexte distribué, chaque Processus (tournant sur une machine
 Temps: qu’on est ce qu’une action doit être lancée?? distante) possède sa propre horloge
 Comment garantir l’exclusion mutuelle dans un contexte distribué? Comment définir un temps global cohérent et « identique » (ou presque)
 Election pour tous les processus
 Consensus
 Tolérance aux pannes

136 137
138