Programmation Objet en JAVA

Cours 10 : Thread (fin) / Réseau (début)

PLAN

• Petits rappels

• Réseau (introduction)

• Applet

• RMI

Remarques

• Le partiel :

– Les notes bientôt.

– Le cours, le cours ...

• Le contrôle continu

• L’examen :

– Des questions de cours

– Des questions de TD

– Un problème.

• Le projet :

– Où en êtes vous ?

– TD sur les interfaces graphiques

Threads, résumé

• Un thread est un fil d’instruction indépendant au sein de la machine virtuelle.

• La machine virtuelle est un processus lançant plusieurs threads.

– un thread est dédié au main de l’application lancée.

– Une application peut lancer à son tour d’autres threads.

• Une application « multi-threaded » peut effectuer plusieurs tâches en

parallèle :

– accès réseau/disque, périphériques (imprimante)

– gestion des événements graphiques

– effectuer plusieurs traitements en parallèle.

Threads, manipulation

• Un processus léger ou thread se manipule par un objet de type

Thread : démarrage, les choses à faire, ...

• Un objet Thread possède un attribut de type Runnable qu’on pourrait

nommer « todo » :

– l’interface Thread impose la méthode run().

– Lorsqu’un thread est démarré (start), appel de « todo.run() ».

– Parfois, todo = this; (Thread implémente Runnable).

Threads, partage des données

• Synchroniser ce que l'on veut, sur ce que l'on veut.

synchronized(syncObject){ /* Ce code ne peut être exécuter que par un seul thread à la fois */ ...}

synchronized void myMethod () { ... }

void myMethod () { synchronized (this) { ... } }

• Ainsi les 2 morceaux de codes suivants sont équivalents.

Verrou (lock)

• Chaque objet possède un « «monitor » en tant qu'Object.

• Lors de l'appel d'une méthode synchronized :

– l'objet est-il accessible (non-vérouillé) ?

• si oui, la méthode est exécutée et l'objet verrouillé;

• si non, la méthode doit attendre la levée du verrou (que la

méthode qui « a le verrou » ai terminé).

• Un seul verrou est partagé par toutes les méthodes synchronized.

wait en détail (I. Charon)

• wait est héritée de la classe Object. • Cette instruction s’utilise dans un code synchronisé. • Le thread en cours d'exécution attend. La méthode doit être invoquée sur

l'instance verrouillée. Typiquement, on pourra écrire :synchronized(UnObjet){ ... while (condition) unObjet.wait(); ...}

• Le thread en cours d'exécution est bloqué par unObjet. • L'instruction unObjet.wait() signifie que unObjet bloque le thread en cours

d'exécution. Ce n'est pas unObjet qui attend.• Il est fréquent que la condition condition porte sur les attributs de unObjet

mais ce n'est pas obligatoire.• Pendant que le thread attend, le verrou sur unObjet est relâché.

notify en détail (I. Charon)

• Pour pouvoir débloquer un thread qui attend, bloqué par unObjet :

synchronized(refereMemeObjetQuUnObjet)

{

...

refereMemeObjetQuUnObjet.notify();

...

}

• Si plusieurs threads sont dans l’attente imposée par unObjet, l'instruction notify() débloque celle qui attend depuis le plus longtemps.

• Sinon notifyAll().

• Signalons qu'il existe aussi wait(long temps) qui termine l'attente après temps millisecondes, si cela n'est pas fait auparavant.

Planification des threads

• Lorsqu'un thread est lancé, il garde la main jusqu'à ce qu'il atteigne un des états suivants :

– Sleeps : appel de Thread.sleep() ou wait().

– Waits for lock : une méthode synchronized est appellée, mais le thread

n'a pas le verrou.

– Blocks on I/O : lecture de fichier, attente reseau.

– Explicit yield control : appel de yield().

– Terminates : la méthode run() du thread est terminé ou appel de stop().

• Qui prend la main ensuite ?

Timer : Simple et Utile

• Pragmatiquement

– Un Thread pour repousser une action dans le temps

• Dans 3 secondes, si l’utilisateur n’a pas bougé sa souris, afficher

un popup disans « Ce bouton sert à quitter le document »

– Un Thread pour répéter une action régulièrement

• Tous les 0.5 secondes, redessine la barre de progression.

• Pour ces cas simple, pas besoin de faire des Threads compliqués :

Utiliser un Timer !

Exemple

• Tutorial Java ->Essential ->Threads ->Timer

• http://java.sun.com/docs/books/tutorial/essential/threads/timer.html

– Déclencher une action tout en continuant

– Déclencher une action après n millisecondes

– Déclencher des actions toutes les p millisecondes

Exemple de Timer

import java.util.Timer;import java.util.TimerTaskpublic class Reminder { private Timer timer; // l'attribut timer est initialisé dans le constructeur public Reminder(int seconds) { timer = new Timer(); // Définition du planning timer.schedule(new RemindTask(), seconds*1000); } // Un timer exécute une tâche de type TimerTask (comparable au // thread!). Définit ici en classe interne : accès aux attributs. class RemindTask extends TimerTask { public void run() { System.out.println("Time's up!"); timer.cancel(); //Terminate the timer thread } } public static void main(String args[]) { new Reminder(5); System.out.println("Task scheduled."); }}

plus propre - 1

import java.util.Timer;import java.util.TimerTask;

public class Reminder2 { private Timer timer; // Pour le timer est la tâche puisse communiquer : reférences croisées public Reminder2(int seconds) { timer = new Timer(); timer.schedule(new ReminderTask2(this), seconds*1000); } // méthode de contrôle du timer : pour l'extérieur public void stopAll(){ timer.cancel(); } public static void main(String args[]) { new Reminder2(5); System.out.println("Task scheduled."); }}

plus propre - 2

import java.util.TimerTask;

public class ReminderTask2 extends TimerTask { // reférences croisées : suite et fin

private Reminder2 rem; ReminderTask2(Reminder2 r){ rem=r; }

public void run() { System.out.println("Time's up!"); rem.stopAll(); }}

Un timer pour répéter

public class AnnoyingBeep { Timer timer; public AnnoyingBeep() { timer = new Timer(); timer.schedule(new RemindTask(),0,1*1000); } class RemindTask extends TimerTask { int numWarningBeeps = 3; public void run() { if (numWarningBeeps > 0) { System.out.println("Beep!"); numWarningBeeps--; } else { System.out.println("Time's up!"); //timer.cancel() is ot necessary because we call : System.exit(0); //stops the AWT thread and everything else. } } } ...}

timer.schedule(...)

• Avec cette méthode (ou ses variantes), il est possible de faire beaucoup de choses.

– schedule(TimerTask task, long delay, long period)

– schedule(TimerTask task, Date time, long period)

– scheduleAtFixedRate(TimerTask task, long delay, long period)

– scheduleAtFixedRate(TimerTask task, Date firstTime, long period)

PLAN

• Petits rappels

• Réseau (introduction)

• RMI

• Applet

Rappel sur les E/S

• Entrées-sorties, le package : java.io.*

• Basées sur la notion de stream (flux) : un canal de communication avec un écrivain à une extrémité et un lecteur à l'autre.

• Les classes de base :

– InputStream/OutputStream classes abstraites définissant les opérations de base pour la lecture/écriture de séquence d'octets

– Reader/Writer classe abstraites définissant les opérations de base pour la lecture/écriture de séquence de données de type cacactère et supportant l'Unicode.

– Les méthodes principales : read(...) et write(...), close()

• java.io.IOException

Flux d’entrée / Flux de sortie

Entrée

Ex : lire un fichier

Nous sommes la destination

Sortie

Ex : écrire un fichier

Nous sommes la source

Schéma de programmation

• Choisir son gestionnaire de flux :– Basé sur des caractères : XxxReader/Writer– Basé sur des octets : XxxInputStream/OutputStream

• Ex : lire un fichier • c’est du texte : FileReader• Des octets : FileInputStream

1. Ouvrir un flux F (connexion)• Passe par la construction d’un ou plusieurs objets, afin

de s’adapter aux besoins.

• Lire ou écrire sur F• appel de read ou write

1. Fermer F A ne pas oublier.• close

E/S : combinaisons de flux

• Combinaison de streams

• Systèmes d'enveloppes successives (Wrapper) que l'on met en cascade :

– « Bufferisation » envelopper le flux à bufferiser dans un Buffered???Stream pour améliorer les performances :

InputStream bufferedIn = new BufferedInputStream(unInputStream);

– Utiliser le flux spécialisé de données pour accéder facilement aux données de types primitifs :

DataInputStream dis = new DataInputStream( System.in );

doudle d = dis.readDouble();

– Transformations en chaîne de caractères PrintWriter méthodes print(), println()

• Il est facile (très facile) de se perdre. • Garder sous la main suffisement d'exemples, pour trouver son bonheur :

– Thinking in Java, Bruce Eckel (Chap 11).

Exemple d'entrées

public static void main(String[] args) throws IOException {//Reading input by lines:BufferedReader in = new BufferedReader(new FileReader("/home/allauzen/foo"));String s;while((s = in.readLine())!= null){...}in.close();//Reading standard input:BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in)); System.out.print("Enter a line (ended with empty line):");while((s = stdin.readLine()).length() != 0){...}stdin.close();// Input from memoryStringReader in2 = new StringReader(s2);int c;while((c = in2.read()) != -1) System.out.print((char)c);// Formatted memory inputtry { DataInputStream in3 = new DataInputStream(new ByteArrayInputStream(ba)); while(true) System.out.print((char)in3.readByte());} catch(EOFException e) { System.err.println("End of stream");} ....

adapté du livre de Bruce Eckel.

Exemple de sorties

public static void main(String[] args) throws IOException {// Print a BufferedReader in file BufferedReader in; // ... try { PrintWriter out1 = new PrintWriter(new BufferedWriter(new FileWriter("foo"))); int lineCount = 1; while((s = in.readLine()) != null ) out1.println(lineCount++ + ": " + s); out1.close();} catch(EOFException e) { System.err.println("End of stream");}

try { DataOutputStream out2 = new DataOutputStream(new BufferedOutputStream( new FileOutputStream("/home/allauzen/foo")));out2.writeDouble(3.14159);out2.writeChars("That was pi\n");out2.writeBytes("That was pi\n");out2.close();} catch(EOFException e) { System.err.println("End of stream");}

adapté du livre de Bruce Eckel.

Introduction au réseau

• Un réseau c'est l'interconnexion de machines (ordinateurs, périphériques).

• Un noeud est une machine : un hôte (host). • Pour échanger des données, un protocole est indispensable :

– TCP : Transport Control Protocol.• Le protocole TCP est « sécurisé » : il est fiable et ordonné.

– accusé de réception pour les données, gestion des erreurs de transmissions, ...

• Il existe un autre protocole : UDP User Datagram Protocol.

– Plus rapide, moins fiable.

– Dédié aux échanges nécessitant de la rapidité au détriment de la fiabilité (un peu de perte, ce n'est pas toujours grave).

Introduction au réseau (suite)

• Pour repérer un noeud du réseau, on utilise un adresse : adresse internet, utilisant l'internet protocol : IP.

• Entre l'adresse et le nom il y a le server DNS (Domain Name System).

• Le protocole de communication (ce n'est pas le protocole de transport).

– http, ftp, telnet, ... . • Architecture de la communication : client/serveur. • Chaque hôte peut fournir plusieurs services : ftp, mail, http. Un hôte

possède alors plusieurs port. • Pour repérer une ressource sur internet : URL (Uniform Resource

Location).

Java et le réseau

• Faire le point sur ce dont on a besoin :– Faire communiquer des applications sur des machines distinctes et

distantes. – Echanger des ressources à travers le réseau.– Travailler à plusieurs et à distance. – Centraliser les infos sur un serveur.

• Java est un langage qui est par essence lié au réseau. • La base : le package java.net. • Avec Java, travailler sur le réseau est proche du travail sur les fichiers.

Identification d'une machine

• Internet Protocole : identification unique d'une machine, IP address. Existe sous deux formes :

1. La forme lisible DNS (Domain Name System) : ftp.limsi.fr.

2. La forme illisible « Dotted Quad » : 192.44.78.17• Le lien entre les deux formes se fait via un server DNS. • Une IP address est représentée dans les 2 cas par un nombre sur 32

bits. • Chaque « quad » nombre est compris entre 0 et 255. • En Java pas de souci, il existe une classe qui gère l'IP address :

InetAddress.• Pour les protocoles IPv4 et IPv6, il existe les classes Inet4Address

et Inet6Address qui hérite de InetAddress.

La classe InetAddress

• classe représentant une adresse IP.

• Peut être utilisé en local, sur réseau local, ou en global. • «  The InetAddress class has a cache to store successful as well as

unsuccessful host name resolutions. »

static InetAddress getByAddress(byte[] addr)

Returns an InetAddress object given the raw IP address .

static InetAddress getByAddress(String host, byte[] addr)

Create an InetAddress based on the provided host name and IP address No name service is checked for the validity of the address.

static InetAddress getByName(String host)

Determines the IP address of a host, given the host's name.

Exemple d'utilisation de la classe InetAddress

import java.net.*;public class WhoAmI { public static void main(String[] args) throws Exception { if(args.length != 1) { System.err.println( "Usage: WhoAmI MachineName"); System.exit(1); } InetAddress a =

InetAddress.getByName(args[0]); System.out.println(a); }}

du livre de Bruce Eckel, utile si vous n'avez pas d'adresse IP fixe.

> java WhoAmI ftp.limsi.frftp.limsi.fr/192.44.78.17

> java WhoAmI popeyepopeye/199.190.87.75

Tester ses programmes sans réseau

• Si vous n'avez pas de réseau sous la main (pas de connexion) et encore moins plusieurs machines ?

• L'Internet Protocol a prévu l'adresse localhost : « the local loopback »

• En Java :

– InetAddress addr = InetAddress.getByName(null);

– InetAddress.getByName("localhost");

– InetAddress.getByName("127.0.0.1");

le port

• L'adresse IP n'est pas suffisante : il peut y avoir plusieurs « server » sur une même machine.

• L'idée :

– en s'adressant à un port, on s'adresse à un service particulier, celui qui est associé à ce port.

– chaque service (server) est associé à un numéro de port. • Un port ne correspond à aucune réalité physique, c'est une

abstraction logicielle.• Pour se connecter à une machine, il faut son adresse et choisir un

port. • Le système se réserve les ports de 1 à 1024.

Serveurs et clients

• L'objectif premier est de connecter ensemble 2 machines et de les faire communiquer.

• La méthode pour se retrouver, comme dans une gare :

– l'une ne bouge pas et observe si on la cherche : le server

– l'autre cherche : le client• La notion de client/server est fondamentale pour la connexion de 2

machines, mais ne présume en rien des rôles futurs des machines, cependant ... .

• Après la connexion, les 2 machines peuvent communiquer via les mécanismes d'entrées/sorties usuels.

• Un client peut initier (demander) une connexion, alors que le serveur peut accepter une connexion, il doit donc être attentif.

La communication

• Via TCP :

• chaque extrémité d'une connexion = « terminal » : socket

• une socket par client

• A chaque socket est associé un flux d'E/S.

• Une socket représente la connexion à une machine (adresse IP)+ un

service particulier (un numéro de port)

• Via UDP :

• une seule socket qui reçoit tous les paquets des clients

• demultiplexage : via le port et l'adresse.

socket

« The socket is the software abstraction used to represent the terminals of a

connection between two machines. »

• Pour une connexion entre 2 machines, il y a un hypothétique câble qui relie

les 2, et à chaque extrémité, il y a 2 sockets : java.net.Socket.

• En Java, on crée une socket pour se connecter à une autre machine.

– A partir ce cette socket, sont accessibles un InputStream et un

OutputStream (ou avec les convertisseurs adaptés un Reader et un

Writer)

– La connexion est alors considérée comme un flux d'E/S.

Socket : une prise réseau

ServerSocket

• En plus le server a besoin d'un ServerSocket :

– un objet qui attend une connexion,

– bloqué sur l'appel de sa méthode accept() qui renvoie une socket.

• Un server nécessite 1 ServerSocket et autant de Socket que de

client.

• Un ServerSocket produit des sockets, ce n’est pas une socket.

ServerSocket - 2

Un client

// Attention aux importstry { Socket server = new Socket(toto.free.fr",8080); InputStream in = server.getInputStream(); OutputStream out = server.getOutputStream(); // Write a byte out.write(42); // Say "Hello" (send newline delimited string) PrintStream pout = new PrintStream( out ); pout.println("Hello!"); // Read a byte Byte back = in.read(); // Read a newline delimited string DataInputStream din = new DataInputStream( in ); String response = din.readLine(); server.close(); } catch ( UnknownHostException e ) { System.out.println("Can't find host."); } catch ( IOException e ) { System.out.println("Error connecting to host."); }

• Une socket donne accès à un flux d'E/S générique

• Qu'il est possible de

spécialiser

• Attention à la fermeture

de la socket.

• Gestion efficace des

Exceptions.

• Pour les E/S on peut

bufferiser (utilisation de

BufferReader et Writer).

Un server

// pendant ce temps sur monserver.free.frtry { ServerSocket listener = new ServerSocket(8080); Socket aClient = listener.accept(); // la connexion est établie, ... InputStream in = aClient.getInputStream(); OutputStream out = aClient.getOutputStream(); // Read a byte Byte importantByte = in.read(); // Read a string DataInputStream din = new DataInputStream( in ); String request = din.readLine(); // Write a byte out.write(43); // Say "Goodbye" PrintStream pout = new PrintStream( out ); pout.println("Goodbye!"); aClient.close(); listener.close(); } catch (IOException e ) { }

• Du coté du server, d'abord on « écoute », attentif aux requètes extérieures.

• Même communication

via un flux d'E/S.

• Attention à tout fermer.

• Voici pour le principe,

mais :

• single-threaded !

• un seul client !

• une seule réponse !

Un server http – 1

import java.net.*;

import java.io.*;

import java.util.*;

/* Un navigateur lance une requète à un server http de la forme :

GET /path/filename [optional stuff]

*/

public class TinyHttpd {

public static void main( String arg[] ) throws IOException {

ServerSocket ss=new ServerSocket(Integer.parseInt(argv[0]));

while ( true )

new TinyHttpdConnection( ss.accept() );

}

}

Un server http – 2

public class TinyHttpdConnection extends Thread {

Socket sock;

TinyHttpdConnection ( Socket s ) {

sock = s;

setPriority( NORM_PRIORITY - 1 );

start();

}

public void run() {

try {

// Pour répondre

OutputStream out = sock.getOutputStream();

// Pour traiter la requète

String req =

new DataInputStream(sock.getInputStream()).readLine();

System.out.println( "Request: "+req );

Un server http – 3

StringTokenizer st = new StringTokenizer( req );

if ((st.countTokens() >= 2) && st.nextToken().equals("GET")){

if ( (req = st.nextToken()).startsWith("/") )

req = req.substring( 1 );

if ( req.endsWith("/") || req.equals("") )

req = req + "index.html";

try {

FileInputStream fis = new FileInputStream ( req );

byte [] data = new byte [ fis.available() ];

fis.read( data );

out.write( data );

} catch ( FileNotFoundException e )

new PrintStream( out ).println("404 Not Found");

} else

new PrintStream( out ).println( "400 Bad Request" );

sock.close();

// Finir par traiter les Exceptions du try du slide précédent.

Attention !

• On préfère hériter de Thread que d'implémenter l'interface Runnable.

• N'essayer pas ça chez vous :

– ça marche, mais ce n'est pas sécurisé.

– Aucune restriction d'accès : tous les fichiers peuvent être accessibles.

• En java il existe une classe java.lang.SecurityManager dont on hérite pour spécifier les contrôles.

• Une instance de SecurityManager peut être installée une seule fois dans un Java run-time environment. Après, tous les accès aux ressources système sont controlés :

– lecture/ecriture/suppression de fichier

– execution de thread, de processus

– connexion, création de server, ....

• La classe contient un ensemble de méthodes « checkXXX ». Si « checkXXX » n'est pas implémentée, la ressource « XXX » n'est pas accessible.

Sécurité extrème

class FascistSecurityManager extends SecurityManager { }

public class MyApp {

public static void main( Strings [] args ) {

System.setSecurityManager( new FascistSecurityManager() );

// No access to files, network, windows, etc.

...

}

}

Exemple de sécurité pour http

class TinyHttpdSecurityManager extends SecurityManager {

public void checkAccess(Thread g) { };// Accès au thread

public void checkListen(int port) { }; // ServerSocket

public void checkPropertyAccess(String key) { }; // system prop.

public void checkAccept(String host,int port){ };// Socket

....

public void checkRead( String s ) {

if ( new File(s).isAbsolute() || (s.indexOf("..") != -1) )

throw new

SecurityException("Access to file : "+s+" denied.");

}

}

Une U.R.L

• Uniform Ressource Identifier : pointe sur un objet sur Internet.

• En général :

– protocole://hostname/location/item

– ex: http://www.limsi.fr/Individu/allauzen/index.html• Le protocole est souvent http ou ftp.• hostname désigne « une machine » : un server. • Une URL peut désigner un objet static (Web server, ftp) ou

dynamique (script, server de news, ... ).• L'URL peut également inclure des informations sur le port, sur une

partie de l'objet pointé, ... . • L'URL peut être relative.

La classe URL

• Une URL est représentée par une instance de la classe java.net.URL.

• Ce type d'objet propose des méthodes pour la manipulation de l'information contenue dans l'URL, ainsi que de l'objet pointé.

try {

URL myUrl = new URL("http://www.limsi.fr/index.html");

URL uneAutre = new URL("http","www.limsi.fr","index.html");

}

catch ( MalformedURLException e ) {/* .... */}

• Les deux URLs pointent sur le même objet.

• Attention à l'exception.

A partir d'un objet URL

• getProtocol(), getHost(), getFile()

• sameFile() d'un point de vue réseau. • A la création de l'URL, Java cherche parmi ses protocol handler le

bon. S'il en trouve pas : exception. • Pour accéder à la ressource, il est toujours possible d'utiliser un

InputStream : renvoyé par la méthode openStream(). • Par exemple, pour lire une ligne d'un fichier html :

try { URL url = new URL("http://server/index.html"); DataInputStream dis = new DataInputStream( url.openStream() ); String line = dis.readLine(); } catch ...

• l'objet de type InputStream (qui lit des octets) est enveloppé dans un objet DataInputStream, plus approprié (ligne de texte).