Résumé de module Programmation distribué 2020/2021

Chapitre I :
Systèmes
Séquentiel : composé une seule entité.
Centralisé : composé de plusieurs entité communicantes.
Distribué : s’exécute sur un ensemble de machine sans mémoire partagée ↔ un système
logiciel composé de plusieurs entités s’exécutent indépendamment et en parallèle sur un
ensemble d’ordi connecté au réseaux.
Répartie : quand une machine tombe en panne, le système nous empêche de travailler

Programmes
Parallèle : exécutent des taches simultanément, en même temps sur des processeurs
différent ↔ synchroniser des processus entre eux à travers d’une mémoire partager.

Concurrent : plusieurs processus qui ne partage pas la même zone mémoire ↔ décomposé
en taches pouvaient être exécutées sur un ordre quelconque.

Processus VS Thread
Processus : est un programme au cours d’exécution qui possède son propre espace
mémoire

Thread : une unité d’exécution qui peut effectuer des taches en parallèles avec d’autre
threads ↔ processus léger

Extends thread :
Avantage : chaque thread a ses propres données qui lui sont propre
Inconvénient : pas d’héritage d’une autre class

Implements runnable :
Avantage :
 Héritage reste possible
 On peut implémenter au tant d’interfaces que l’on souhaite
Inconvénient : les attributs de la class sont partagés pour tous les threads

Get : fournir Set : changer

 Résumé de module Programmation distribué 2020/2021

Synchronisation
Synchronisation des blocs : utiliser synchronized en indiquant l’objet auquel il faut limiter
l’accès.

Synchronisation des méthodes : utiliser synchronized dans la définition de la méthode.

Communication entre Threads

Wait : met un thread en sommeil jusqu’à un appel sur le même objet.
Notify : démarrage de premier thread qui on a appelé wait.
Notify all : démarre tous les threads.

Principe des modes connecté et non connecté

Mode connecté TCP :
Serveur :

 Créer une socket serveur.

 Associer la socket à un port.
 Attendre une demande de connexion.
 Communiquer.
Client :

 Créer une socket de communication.

 Connecter à IP et port associé au serveur (via la socket).
 Communiquer.

Mode déconnecté UDP :

A :

 Créer une socket datagramme.

 Associer la socket à un port.
 Créer un paquet datagramme.
 Envoyer le datagramme (à l’IP + Port).
B :

 Créer une socket datagramme.

 Associé la socket à un port.
 Attendre la réception de datagramme
Les fonctionnalité codé dans A et B qui vont définir lequel est le serveur et lequel est client.
 Résumé de module Programmation distribué 2020/2021

LES CLASS
TCP :
1. utilise la class Serversocket elle écoute le réseau et attends une connexion.
2. IL n’y a pas de méthode d’envoie et de réception.
3. Pour communiquer il utilise les class de flux ils sont obligatoire.
4. Socket contient :
 getInputStream : réception une instance de flux d’octet entrant.
 GetOutputStream : Envoyer une instance de flux d’octet sortant.

Si une appli doit communiquer uniquement du texte :

DufferedReader / PrintStream (lire / écrire des lignes du texte).

Dans tout autre situation :

ObjectInputStream / ObjectOutputStream (lire / écrire n’importe quel type de données).

UDP :
1. Utilise la classe DatagramSocket contient les methodes :
 Envoyer (send).
 Recevoir (Receve).
2. Les données sont enpaquetées dans l’objet DatagramPacket.

RPC VS RMI
RPC : est un mécanisme qui permet d’appeler une procédure sur un ordi distant.
RMI : est l’implémentation de RPC en java.

I) RPC (Remote Procedure Call)

 Est un protocole qui permet de faire des appels de procédure sur un ordi
distant à l’aide d’un serveur d’application.
 Est utilisé pour assurer la communication entre le client/server.

Intérêt :
- Structuration simple du code.
- Abstraction du réseau.
- Facilité des maj.

Limite :
- Permet de transporter qu’un jeu limité de type de data simple.
- N’est pas idéal pour le passage et le retour d’objet java.
- Mécanisme de bas niveau.
 Résumé de module Programmation distribué 2020/2021

Problèmes :
- Traitement de défaillances.
- Problème de sécurité.

Evaluation :
- CORBA, JAVA RMI, SOAP.

II) RMI (Remote Méthode Invocation)

 Permet la communication entre machine virtuelle JAVA (JVM) qui permet
se trouver physiquement sur la même machine distantes.

Dévloppement :
Serveur :
- Définir une interface qui contient les méthodes qui peuvent être
appeler à distant.
- Ecrire une class qui implémente l’interface.
- Ecrire une class qui instancie l’objet puis l’enregistrer en lui
affectant un nom dans le registre de mon RMI.
Client :
- Obtenir une référence sur l’objet distant à partir de son nom.
- Appeler la méthode à partir de la référence.
 Résumé de module Programmation distribué 2020/2021

Exemple TCP :
package Server;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class MyServer {

public static void main(String[] args) throws Exception {

/*L'objet server socket quand on lui a attribuer un numero de port à ce serveur ça peut qu'il est
deja occupé par une autre application au moment d'exécution dans ce cas la il nous génére une exception
nous avons besoin de faire un try catch ou bien un throws exception (ne pas traiter les exception)*/
ServerSocket ss=new ServerSocket(1234);
System.out.println("j'attends la connexion");
//la methode accept() est blocante elle nous retourne une socket on récupère la socket par s
Socket s=ss.accept();
System.out.println("Connexion d'un Client "+ s.getRemoteSocketAddress());//il nous retourne @ du client
//générer les objets InputStream et outputStream
InputStream is=s.getInputStream(); // is avec le quel je peux lire les requete du client
OutputStream os=s.getOutputStream();// os avec le quel je peux envoyer une rèponse au client
System.out.println("j'attends que le client m'envoie un octet");
int nb= is.read(); //on attends l'octet qui va etre envoyer par le client et on le stocke dans la variable nb
System.out.println("j'ai reçu un nombre par le client "+ nb);
int res= nb*5;
System.out.println("j'envoie la réponse au client "+ res);
os.write(res); //on envoie la reponse après avoir effectué le calcule
os.close();//fermer la connexion

package Client;

import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Scanner;

public class MyClient {

public static void main(String[] args) throws Exception{

System.out.println("je me connecte au serveur");
Socket s=new Socket("localhost", 1234);
InputStream is=s.getInputStream();
OutputStream os=s.getOutputStream();
//saisir un nombre au clavier
Scanner sc=new Scanner(System.in);
System.out.print("Donner un nombre ");
int nb=sc.nextInt();
System.out.println("j'envoie le nombre "+nb+" au serveur");
os.write(nb);
System.out.println("j'attends la réponse du serveur ");
int rep=is.read();
System.out.println("La réponse du serveur est : "+rep);
}

}
 Résumé de module Programmation distribué 2020/2021

Exemple UDP :
package serveur;
import java.net.*;
import java.io.*;
import java.util.*;

public class Serveur {

public static void main(String[] args) throws Exception{

//Scanner sc = new Scanner(System.in);
//int n=sc.nextInt();
byte [] t =new byte[50];

System.out.println("j'attends la chaine de caractère");

DatagramSocket s= new DatagramSocket(2021);
DatagramPacket p= new DatagramPacket(t, t.length);
s.receive(p);
System.out.println("Reception");
String ch = new String(t);
String M = ch.toLowerCase();
System.out.println(M);

DatagramSocket r= new DatagramSocket();

// byte [] t = new byte[50];
t=M.getBytes();
InetAddress adr= p.getAddress();
int port = p.getPort();
DatagramPacket pr=new DatagramPacket(t, t.length, adr, port);
s.send(pr);

package client;
import java.net.*;
import java.io.*;
import java.util.*;
public class Client {

public static void main(String[] args) throws Exception{

Scanner sc = new Scanner(System.in);

String ch= sc.nextLine();

// int n=sc.nextInt();
DatagramSocket e= new DatagramSocket();
byte [] t = new byte[50];
t=ch.getBytes();
InetAddress adr= InetAddress.getByName("localhost");
DatagramPacket p=new DatagramPacket(t, t.length, adr, 2021);
e.send(p);

DatagramPacket pr= new DatagramPacket(t, t.length);

e.receive(pr);
System.out.println("Reception");
ch = new String(t);

System.out.println(ch);

// e.close();

}
}