Les classes

Stream et Thread
INF2120
Programmation II
Bruno Malenfant
v-223
Stream
• Stream<T> est un interface Java.
• Cette interface existe depuis Java 8.
• Elle représente une suite d'éléments pouvant supporter des
operations séquencielles et parallèles.
• Les streams permettent de déclarer (description déclarative) les
sources et les manipulations appliquées sur l'ensemble de ces
sources.
Utilisation
1. Initiation : un stream peut être construit à partir d'une structure.
Aussi, il existe des opérations pour construire des streams sans
structure.
2. Construction : ensuite, des opérations sont ajoutées pour
manipuler les informations du stream.
3. Démarrer : finalement, une opération est ajoutée pour
démarrer/terminer le stream (terminal).
1. Initiation
• À partir d'une structure :
ArrayList< Integer > a = new ArrayList();
...
Stream< Integer > s = a.stream();

• Sans structure : utiliser des méthodes comme generate,

iterate.
Stream< Integer > s =
Stream.iterate( 0, (x) -> x < 10, (x) -> x + 1 );
2. Construction
• Ajouter des transformations (mapping).
ArrayList< Integer > a = new ArrayList();
...
Stream< Integer > s = a.stream();
Stream< Integer > s2 = s.map( (x) -> 2 * x + 1 );

• Ajouter des filtres.

ArrayList< Integer > a = new ArrayList();
...
Stream< Integer > s = a.stream();
Stream< Integer > s2 = s.map( (x) -> 2 * x + 1 );
Stream< Integer > s3 = s2.filter( (x) -> x < 10 );
3. Démarrer
• Ajouter une opération 'terminal' au stream.
1. Pour afficher
ArrayList< Integer > a = new ArrayList();
...
Stream< Integer > s = a.stream();
Stream< Integer > s2 = s.map( (x) -> 2 * x + 1 );
Stream< Integer > s3 = s2.filter( (x) -> x < 10 );
s3.forEach( System.out::println );
3. Démarrer (suite)
2. Pour ramasser (collect).

ArrayList< Integer > a = new ArrayList();

...
Stream< Integer > s = a.stream();
Stream< Integer > s2 = s.map( (x) -> 2 * x + 1 );
Stream< Integer > s3 = s2.filter( (x) -> x < 10 );

ArrayList< Integer > b =

s3.collect( Collectors.toCollection( ArrayList::new ) );
Parallèle
• Lors de la construction du stream.
• stream() : le stream est séquentiel.
• parallelStream() : le stream est parallèl.
• Lors de la construction.
• sequential() : rend le stream séquentiel.
• parallel() : rend le stream parallèl.
Thread
• Une classe Java qui implémente l'interface Runnable.
• Runnable est une @FuntionalInterface.
• Elle contient la méthode void run().
• La machine virtuelle de Java permet d'exécuter plusieurs Thread
simultanément. Chaque thread contient sa file d'exécution (Pile de
cadre d'activation pour les méthodes).
Construction
• Construire une classe qui hérite de la classe thread.
• Elle devra avoir une méthode run.
class PT extends Thread { ... void run() ... }

PT p = new PT();
p.start();
• Construire une classe qui implémente l'interface Runnable et ensuite
construire un thread avec cette classe en argument.
class RT implements Runnable { ... void run() ... }

new Thread( new RT() ).start();

Manipulation des Threads
• Il est possible d'endormir un Thread.
• sleep : le Thread fait une pause pour un certain temps (en argument).
• wait : le Thread fait une pause jusqu'a ce qu'il soit réveillé.
• Certaine version du wait inclue un temps d'attente.
Synchronisation
• Chaque instance de classe contient les éléments suivants.
• Monitor (moniteur).
• Indique si l’instance est barré (locked) ou non.
• Liste de Thread endormie.
• Une liste des threads en attente pour le moniteur.
Synchronisation : algorithme
• Losqu’une méthode synchronisée ou une instruction synchronisée
demande l’accès à un object
• Si le moniteur indique que l’objet est barré
1. Le thread contenant la méthode/l’instruction est placé en attente dans la liste de
thread de l’object.
• Si le moniteur indique que l’objet n’est pas barré
1. Le moniteur est placé à la position ‘locked’.
2. La méthode/l’instruction s’exécute.
3. S’il y a au moins un thread dans la liste d’attente de l’object, alors un des threads est
activé.
4. Quand il n’y a plus de thread dans la liste d’attente, le moniteur est placé à la position
‘unlocked’.
Synchronisation : méthode
• Une méthode peut être qualifié avec ‘synchronized’. Dans ce cas, elle
demandera le moniteur de l’objet sur lequel elle est appelé (this). Si
cette méthode est statique (static), alors elle demande le moniteur du
descripteur de classe. Se moniteur est utilisé pour protéger
l’exécution du corps de la méthode.
Exemple de syntaxe
public synchronized void m() {
…
}
Synchronisation : instruction
• Java contient une instruction de synchronisation. Cette instruction
accepte une expression et un block d’instruction.
Exemple de syntaxe
synchronized ( expression ) {
…
}
1. L’expression est évaluée, elle doit donner une référence comme résultat.
2. Le moniteur de l’objet pointé par la référence est utilisé pour protéger
l’exécution du bloc d’instruction.
Synchronisation
• Toutes actions non synchronisées peut accéder au information d’un
objet même si le moniteur est barré.
• C’est donc le travail du programmeur de décider des objects qui
doivent être protégé et de s’assurer que seulement des actions
synchronisées travaille sur ces instances.