(Java avanc%E9 - Nouveaut%E9s JDK 5 [Mode de compatibilité])

Java avancé
"Nouveautés"
"Nouvelles versions"
• J2SE 5.0 - Tiger
– version numérotée 1.5
– sortie le 30 Septembre 2004
– 3 270 classes et interfaces
• Java SE 6 - Mustang
– Sun remplace J2SE par Java SE suivi du numéro de version
– sortie le 11 Décembre 2006
– 3 777 classes et interfaces
• Java SE 7 - Dolphin
– 2011
www.objis.com
Java avancé
2
Ajouts majeurs de la version 5
•
•
•
•
•
•
•
programmation générique (JSR 14)
annotations (JSR 175)
autoboxing/unboxing (JSR 201)
énumérations (JSR 201)
nombre variables d'arguments
imports statiques
syntaxe du for étendu aux itérables
www.objis.com
Java avancé
3
autoboxing/unboxing
• Transformation automatique d'une variable de
type primitif en son wrapper, et inversement
– sous les version précédentes il était nécessaire de
faire cette opération explicitement
public class AutoboxingUnboxingOld
{
@SuppressWarnings("unchecked")
public static void main(String[] args)
{
ArrayList liste = new ArrayList();
for(int i=0 ; i<10 ; i++)
{
liste.add(new Integer(i));
}
}
}
www.objis.com
public class AutoboxingUnboxingNew
{
@SuppressWarnings("unchecked")
public static void main(String[] args)
{
ArrayList liste = new ArrayList();
for(int i=0 ; i<10 ; i++)
{
liste.add(i);
}
}
}
Java avancé
4
Imports statiques
• Il n'est plus nécessaire de préfixer le membre
statique d'une classe par le nom de la classe
– import statique par
import static <package.class>;
import static java.lang.Math.*;
public class StaticOld
{
public static void main(String[] args)
{
System.out.println(Math.PI);
}
}
www.objis.com
public class StaticNew
{
public static void main(String[] args)
{
System.out.println(PI);
}
}
Java avancé
5
Méthodes à nombre d'arguments variables
• Passage d'un nombre indéfini d'arguments de
même type à une méthode
– utilise une nouvelle notation, trois points ...
– le paramètre dans la
méthode est traité comme
un tableau
– les valeurs peuvent être
passées sous forme de
tableau
public class ArgumentsVariables
{
public static void main(String[] args)
{
int[] valeurs = {1,2,3,4};
System.out.println(additionner(5,6,7));
System.out.println(additionner(valeurs));
}
public static int additionner(int ...varargs)
{
int total=0;
for(int i=0 ; i<varargs.length ; i++)
{
total += varargs[i];
}
return total;
}
}
www.objis.com
Java avancé
6
Itérations simplifiées
• Parcourir une collection avec un itérateur peut
s'avérer fastidieux
public class IterationOld
{
@SuppressWarnings("unchecked")
public static void main(String[] args)
{
ArrayList liste = new ArrayList();
for(int i=0 ; i<10 ; i++)
{
liste.add(new Integer(i));
}
Iterator it = liste.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
www.objis.com
Java avancé
7
Itérations simplifiées
• La nouvelle forme du for simplifie le parcours
des collection
– peut être utilisé avec les génériques pour éviter un
cast
– ne permet pas
la suppression
de l'élément
courant
public class IterationNew
{
public static void main(String[] args)
{
ArrayList<Integer> liste = new ArrayList<Integer>();
for(int i=0 ; i<10 ; i++)
{
liste.add(i);
}
for(int i : liste)
{
System.out.println(i);
}
}
}
www.objis.com
Java avancé
8
Les énumérations
• Il est souvent nécessaire d'avoir un ensemble fini
de valeurs correspondant à des états
– fréquemment représentées sous formes de
constantes
public interface EtatsMoteur
{
public static final
public static final
public static final
public static final
}
int
int
int
int
ARRET
AVANCE
ARRIERE
RALENTI
=
=
=
=
0;
1;
2;
3;
– pas de contrôle des valeurs utilisées
• valeur supérieure à 4 par exemple
• pas d'obligation d'utiliser les constantes
www.objis.com
Java avancé
9
Les énumérations
• Une nouvelle fonctionnalité permet de déclarer
des énumération
– mot clé enum
– nom de l'énumération
– liste des valeurs possibles
public enum Etats
{
ARRET, AVANCE, ARRIERE, RALENTI
}
• Le compilateur va créer une classe possédant
–
–
–
–
–
un champ static pour chaque élément
une méthode values() renvoyant un tableau des éléments
une méthode valueOf()
l'implémentation de Comparable et Serializable
une redéfinition des méthode toString(), equals() et compareTo()
www.objis.com
Java avancé
10
Les énumérations
• A l'utilisation le compilateur va pouvoir contrôler
le type et les valeurs
public class TestEnum
{
public static void main(String[] args)
{
controler(Etats.RALENTI);
}
public static void controler(Etats etat)
{
switch(etat)
{
case ARRET:
//
break;
case ARRIERE:
//
break;
case AVANCE:
//
break;
case RALENTI:
//
break;
}
}
}
www.objis.com
Java avancé
11
Sortie standard formatée
• Fonctionne comme la fonction printf(...) du
langage C
public class SortieFormatee
{
public static void main(String[] args)
{
String texte = "Le résulat de ";
double a = 12, b=25;
Calendar now = new GregorianCalendar();
System.out.printf("%s %.2f + %.2f est %.2f\n",texte,a,b,a+b);
System.out.printf("Nous sommes le %td/%tm/%tY\n",now,now,now);
}
}
– les codes formats sont inspirés du C
• beaucoup plus complet
– conversion des dates, heures
• reportez vous à la javadoc de la classe
java.util.Formatter
www.objis.com
Java avancé
12
Gestion des flux standards : Scanner
• Scanner fournit les fonctionnalités de base
pour lire tous les flux standards
• Peut être utiliser pour convertir du texte en
primitives ou en String
• Possibilité d'utiliser des expressions régulières
pour la lecture du flux
– reportez-vous à la javadoc de la classe
java.util.Scanner
www.objis.com
Java avancé
13
Gestion des flux standards : Scanner
• Exemple d'utilisation
public class TestScanner
{
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
String s = sc.nextLine();
System.out.printf("lecture de %d - %s",i,s);
sc.useDelimiter("<");
int a = sc.nextInt();
int b = sc.nextInt();
System.out.printf("%d %d", a,b);
}
}
www.objis.com
Java avancé
14
Les génériques
• Amélioration de la lisibilité du code
• Amélioration de la sécurité d'exécution
– plus de cast nécessaire pour les éléments de
collection
• le cast ne peut être vérifié qu'à l'exécution tandis que les
types le sont par le compilateur
• Seuls les objets sont utilisables avec les types
génériques
• Utilisation des symboles < et > pour préciser le
type
www.objis.com
Java avancé
15
Les génériques
• L'utilisation conjointe des types génériques et de
la bouclez for rend le code plus lisible
public class IterationNew
{
public static void main(String[] args)
{
ArrayList<Integer> liste = new ArrayList<Integer>();
for(int i=0 ; i<10 ; i++)
{
liste.add(i);
}
for(int i : liste)
{
System.out.println(i);
}
}
}
www.objis.com
Java avancé
16
Les génériques
• Vous pouvez utilisez les génériques
– dans les classes
– dans les interfaces
– dans les méthodes
• Pour définir une classe utilisant les génériques il
faut les déclarer dans la signature de la classe
– entre < et >
– si la classe utilise plusieurs génériques il faut les
séparés par des virgules
www.objis.com
Java avancé
17
Les génériques
• Exemple de création d'une classe avec types
paramétrés
public class Generic_01<T,U>
{
private T paramT;
private U paramU;
public Generic_01()
{
}
public Generic_01(T paramT, U paramU)
{
super();
this.paramT = paramT;
this.paramU = paramU;
}
public T getParamT()
{
return paramT;
}
...
public void setParamU(U paramU)
{
this.paramU = paramU;
}
}
www.objis.com
Java avancé
18
Les génériques
• Utilisation de la classe
public class Test_01
{
public static void main(String[] args)
{
Generic_01<String, Integer> g = new Generic_01<String, Integer>("Bonjour",3);
System.out.printf("%s %d\n",g.getParamT(),g.getParamU());
}
}
www.objis.com
Java avancé
19
Les génériques : sous-typage
• Il est possible de préciser une relation de soustypage du type générique
– seuls les types hérités pourront être employés dans le
type générique
– utilisation du mot clé extends
public class Generic_02<T extends Number>
{
private T nombre;
public Generic_02(T nombre)
{
super();
this.nombre = nombre;
}
public T getNombre()
{
return nombre;
}
• Utilisation
public class Test_02
{
public static void main(String[] args)
{
Generic_02<Integer> g = new Generic_02<Integer>(3);
}
}
www.objis.com
Java avancé
}
20
Les génériques
• L'utilisation approfondie des génériques est
beaucoup plus riche
– reportez vous à la documentation officielle si vous
avez besoin de créer des traitement complexes sur
des types génériques
• Les types paramétrés ne sont pas exposés (réifiés)
dans le binaire généré
– pas de possibilité d'introspection pour connaitre le
type paramétré
www.objis.com
Java avancé
21
Les génériques
• Le type des tableaux est réifié
– vous ne pouvez pas créer de tableaux sur des types
paramétrés
• car le type T n'est pas réifié
Erreur de compilation
public class Generic_03<T>
{
private T[] tableau;
public Generic_03()
{
tableau = new T[10];
}
public static void main(String[] args)
{
Generic_03<String> t = new Generic_03<String>();
}
}
www.objis.com
Java avancé
22
Les annotations
• Appelées également métadonnées
– préfixées par @
• Marque certains éléments du langage
– classe, propriété et/ou méthode
• Les annotations peuvent être utilisées par :
– le compilateur (SOURCE)
• ou autre outil utilisant le source
– la machine virtuelle, par introspection (RUNTIME)
– présente dans le binaire (CLASS)
• mais pas utilisable par la JVM
• demande un outils externe
www.objis.com
Java avancé
23
Les annotations
• Annotations standards
– @Deprecated
• signale au compilateur que l'élément marqué ne devrait
plus être utilisé
– @Override
• précise au compilateur que la méthode est redéfinie
– sur JDK 1.5 ne marque pas les méthodes héritées d'interface
– @SuppressWarning
• indique au compilateur de ne pas afficher certains warnings
• prend en attribut le nom du warning
www.objis.com
Java avancé
24
Les méta-annotations
• Ce sont des annotations destinées à marquer
d'autres annotations
– package java.lang.annotation
• @Documentated
– indique à javadoc que l'annotation doit être présente
lors de la génération de la documentation
• @Inherited
– par défaut les annotations ne sont pas héritées
– force l'héritage de l'annotation sur les éléments
marqués
www.objis.com
Java avancé
25
Les méta-annotations
• @Retention
– politique de rétention de l'annotation
• RetentionPolicy.SOURCE
– l'annotation n'est pas enregistrée dans le fichier binaire
• RetentionPolicy.CLASS
– l'annotation est enregitrée dans le binaire mais non utilisée par la
JVM
• RetentionPolicy.RUNTIME
– l'annotation est présente dans le fichier binaire
– utilisable par la JVM
www.objis.com
Java avancé
26
Les méta-annotations
• @Target
– limite le type de l'élément sur lequel est utilisée
l'annotation
www.objis.com
Valeur
Utilisation
ElementType.ANNOTATION_TYPE
utilisable sur d'autres annotations
ElementType.CONSTRUCTOR
utilisable sur les constructeurs
ElementType.FIELD
utilisable sur les propriétés d'une classe
ElementType.LOCAL_VARIABLE
utilisable sur les variables locales d'une méthode
ElementType.METHOD
utilisable sur les méthodes
ElementType.PACKAGE
utilisable sur les packages
ElementType.PARAMETER
utilisable sur les paramètres de méthodes ou
constructeurs
ElementType.TYPE
utilisable sur la déclaration d'un type (class,
interface, @interface, enum)
Java avancé
27
Les annotations
• En plus des annotations standards et métaannotations il existe de nombreuses
bibliothèques d'annotations
– pour Hibernate, les EJB3
– annotations spécifiques serveurs JBoss, WebSphere
• Vous pouvez créez vos propre annotations
– automatisation de tâches sur les classes
– utilisation en AOP (Aspect Oriented Programming)
www.objis.com
Java avancé
28
Exemple d'annotation Todo
• Cette annotation est utilisable
– sur le source uniquement
– sans héritage
– gérée par javadoc
– pas de restriction à un type
www.objis.com
Java avancé
29
Exemple d'annotation Todo
• Cette annotation est utilisable par un outil
externe qui analyserait les sources pour trouver
l'annotation
@Documented
@Retention(RetentionPolicy.SOURCE)
public @interface Todo
{
String value();
}
• Utilisation dans une classe
public class UtiliseTodo
{
@Todo(value="code à finaliser")
public void faireQuelqueChose()
{
}
}
www.objis.com
Java avancé
30
Attribut des annotations
• Les méthodes des annotations représentent les
attributs des annotations
– value() représente l'attribut
par défaut s'il est unique
@Documented
@Retention(RetentionPolicy.CLASS)
public @interface Todo
{
String value();
}
public class UtiliseTodo
{
@Todo("code à finaliser")
public void faireQuelqueChose()
{
}
}
• Types acceptés par les attributs d'annotation
– types primitifs, énumérations, java.lang.String,
java.lang.Class, java.lang.annotation.Annotation
www.objis.com
Java avancé
31
Attribut des annotations
• Nous pouvons faire évoluer notre annotation
– niveau de criticité du Todo (level)
• par défaut à MINEUR
@Documented
@Retention(RetentionPolicy.CLASS)
public @interface Todo
{
public static enum Level{MINEUR,NORMAL,IMPORTANT};
String value();
Level level() default Level.MINEUR;
}
www.objis.com
Java avancé
32
Annotation RUNTIME
• Si l'annotation n'est pas standard un conteneur
doit prendre en charge l'annotation
– dans l'exemple suivant le traitement est pris en charge
par une simple classe
• Si l'annotation n'est pas prise en charge par le
conteneur, le comportement de l'instance n'est
pas modifié
www.objis.com
Java avancé
33
Exemple annotation RUNTIME
• Notre annotation permet de changer la valeur
d'une propriété
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.FIELD})
public @interface ChangeProprieteString
{
String value();
}
• Mise en place dans la classe
public class UtiliseChangeProprieteString
{
@ChangeProprieteString(value="Hello World")
private String monMessage="Bonjour";
public void afficher()
{
System.out.println("Valeur du message : "+monMessage);
}
}
www.objis.com
Java avancé
34
Exemple annotation RUNTIME
• Classe traitant l'annotation
– utilisation de l'introspection
public class ChangeProprieteStringProcess
{
// code permettant l'injection de dépendance
public static void injecter(Object obj) throws Exception
{
for(Field field : obj.getClass().getDeclaredFields())
{
if(field.isAnnotationPresent(ChangeProprieteString.class))
{
ChangeProprieteString annotation = (ChangeProprieteString)field.getAnnotation(ChangeProprieteString.class);
field.setAccessible(true);
field.set(obj,annotation.value());
}
}
}
}
www.objis.com
Java avancé
35
Exemple annotation RUNTIME
• "conteneur" lançant, ou non, le traitement de
l'annotation
public class TestChangeProprieteString
{
public static void main(String[] args) throws Exception
{
UtiliseChangeProprieteString test = new UtiliseChangeProprieteString();
ChangeProprieteStringProcess.injecter(test);
test.afficher();
}
}
Si cette ligne de code
est omise la classe
contenant l'annotation ne
voit pas sont
comportement modifié
www.objis.com
Java avancé
36
Java Scripting API
• Avantage des langages de script
– facilité : typage dynamique, conversion de type
automatique, ...
– développement rapide de prototypes
– création d'extension d'application
• scripts de configuration
• encapsulation de règles métier
– utilisation en ligne de commande
www.objis.com
Java avancé
37
Java scripting API
• package javax.scripting
– classe ScriptEngineManager
• mécanisme de découverte des moteurs de script (JavaScript
pour le moment)
• Étapes d'utilisation
– création d'un ScriptEngineManager
– récupération d'un ScriptEngine
– évaluation du script par la méthode eval()
www.objis.com
Java avancé
38
Hello world
• Exemple simple
import javax.script.*;
public class EvalScript
{
public static void main(String[] args) throws Exception
{
ScriptEngineManager factory = new ScriptEngineManager();
ScriptEngine engine = factory.getEngineByName("JavaScript");
engine.eval("print('Hello, World')");
}
}
• Évaluation d'un fichier externe
public class EvalFile
{
public static void main(String[] args) throws Exception
{
String file = "test.js";
ScriptEngineManager factory = new ScriptEngineManager();
ScriptEngine engine = factory.getEngineByName("JavaScript");
engine.eval(new java.io.FileReader(file));
}
}
println("Hello world de test.js");
www.objis.com
Java avancé
39
Exposer des objets Java au script
• Des objets Java peuvent être passés au script
– les membres publiques des objets sont alors
utilisables par le script
public class ScriptVars
{
public static void main(String[] args) throws Exception
{
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
File f = new File("test.js");
// expose l'instance f comme variable 'file' dans le moteur de script
engine.put("file", f);
engine.eval("print(file.getAbsolutePath())");
}
}
www.objis.com
Java avancé
40
Invoquer des fonctions du script
• Si le script encapsule des fonctions métier, il faut
pouvoir les invoquer en Java
public class InvokeScriptFunction
{
public static void main(String[] args) throws Exception
{
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
String script = "function hello(name) { println('Hello, ' + name); }"+
"function add(a,b) {return a+b;}";
engine.eval(script);
Invocable inv = (Invocable) engine;
inv.invokeFunction("hello", "Scripting!!");
Double a = (Double) inv.invokeFunction("add", 2,5);
System.out.println("Résultat de l'addition : "+a);
}
}
– il faut tester si le moteur de script implémente
l'interface Invocable
• ce qui est le cas pour JavaScript
www.objis.com
Java avancé
41
Invoquer des méthode du script
• JavaScript possède des objets
– récupération de l'objet du script
– invocation de la méthode avec passage de paramètre
public class InvokeScriptMethod
{
public static void main(String[] args) throws Exception
{
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
String script = "var obj = new Object();"+
"obj.hello = function(name) { print('Hello, ' + name); }";
engine.eval(script);
Invocable inv = (Invocable) engine;
Object obj = engine.get("obj");
inv.invokeMethod(obj, "hello", "Script Method !!");
}
}
www.objis.com
Java avancé
42
Implémenter des interfaces Java par le
script
• Les interfaces fournissent une couche abstraites
– il peut être intéressant de sortir un traitement de la
couche Java pour le mettre en place dans une couche
JavaScript
• code métier changeant fréquement
• L'exemple suivant montre comment implémenter
la fonction run() de l'interface Runnable
– utilisation de la méthode getInterface()
www.objis.com
Java avancé
43
Implémenter des interfaces Java par le
script
• Implémentation par appel de fonction scriptée
public class RunnableImpl
{
public static void main(String[] args) throws Exception
{
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
String script = "function run() { println('run called'); }";
engine.eval(script);
Invocable inv = (Invocable) engine;
Runnable r = inv.getInterface(Runnable.class);
Thread th = new Thread(r);
th.start();
}
}
www.objis.com
Java avancé
44
Implémenter des interfaces Java par le
script
• Implémentation par appel de méthode d'un objet
scripté
– passage de l'objet sur la méthode getInterface(...)
public class RunnableImplObject
{
public static void main(String[] args) throws Exception
{
ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("JavaScript");
String script = "var obj = new Object(); obj.run = function() { println('run method called'); }";
engine.eval(script);
Object obj = engine.get("obj");
Invocable inv = (Invocable) engine;
Runnable r = inv.getInterface(obj, Runnable.class);
Thread th = new Thread(r);
th.start();
}
}
www.objis.com
Java avancé
45
Les threads
• Un thread (thread of control) est un flux de code qui s'exécute de
manière indépendante
• Les systèmes d'exploitation multitâches permet d'exécuter plusieurs
applications simultanément
– Un processus est un application se déroulant dans un thread et possédant son
propre environnement mémoire
– Un processus peut créer des threads fils.
• Sur une machine mono processeur, à un instant donné, il n'y a qu'un
flux de code exécuté.
– Le processeur est partagés entre les flux de codes par le planificateur
(scheduler) de tâches du système d'exploitation
www.objis.com
Java avancé
46
Les threads
Système d'exploitation
Application # 1
Mémoire partagée
Application # 2
Application # 3
Machine Virtuelle Java (JVM)
Thread # 1
Variables locales
Thread # 2
Variables locales
Thread # 3
Variables locales
Mémoire globale
Thread initial
www.objis.com
Java avancé
47
Les threads
• Chaque thread exécute son code indépendamment des autres
threads
– Les threads peuvent coopérer entre eux
• Les threads donnent l'illusion d'une exécution simultanée de
plusieurs tâches
• Accès aux données par un thread
– Les variables locales des méthodes d'un thread sont différentes pour
chaque thread
• Si deux thread exécutent la même méthode, chacun obtient un espace mémoire
séparé pour les variables locales de la méthode
– Les objets et variables d'instances peuvent être partagés entre les threads
d'un même programme Java.
• Les variables statiques sont automatiquement partagées
www.objis.com
Java avancé
48
Quand utiliser les threads
• Entrées/sorties non bloquantes
– Ne pas bloquer l'application lors de lectures clavier,
réseau, socket, …
– Trois techniques de base
• Multiplexage des entrées/sorties
• Scrutation (polling)
• Signaux
• Alarmes et temporisateurs (timers)
• Tâches indépendantes
– Algorithmes parallélisables
www.objis.com
Java avancé
49
API des Threads
• Utilisation de la classe Thread
– Création d'une classe qui étend la classe
Java Thread
– Redéfinir de la méthode run
void run()
– Créer un nouveau thread et lancer la
méthode run avec la méthode start()
void start()
<<interface>>
Runnable
Thread
– Attendre avec la méthode sleep()
static void sleep(long ms)
static void sleep(long ms, int nano)
www.objis.com
Java avancé
50
API des Threads
• Utilisation de l'interface Runnable
– Créer une classe implémentant l'interface Runnable
– Coder la méthode run()
– Créer un thread en passant la classe d'implémentation
de Runnable en paramètre du constructeur
– Lancer la méthode start du thread, c'est notre
méthode run qui sera lancée
www.objis.com
Java avancé
51
Gestion de la concurrence en Java
• Java utilise des objets actifs pour représenter les
threads
• Communication et synchronisation des threads
– variables partagées, passage par message
• Java utilise la notion de moniteur pour la
communication asynchrone et l'exclusion
mutuelle
www.objis.com
Java avancé
52
Thread : exclusion mutuelle
• Utilisation de mot clé synchronized
public class Coordonnee
{
private int x,y;
public Coordonnee(int x, int y)
{
this.x = x;
this.y = y;
}
public synchronized void update(int newX, int newY)
{
this.x = newX;
this.y = newY;
}
}
www.objis.com
Java avancé
53
Threads : forces et faiblesses
• Points forts :
– modèle simple supporté par le langage
– contrôle de typage fort
– portabilité des programmes
• Points faibles :
– mécanisme de priorité insuffisant
– transfert de contrôle asynchrone : ne pas utiliser les
méthodes stop(), suspend() et resume() sous
risque d'inter-blocage.
www.objis.com
Java avancé
54
Apports de Java 5
• réécriture des final, volatil et
synchronised pour assurer une exécution
correcte sur tout type d'architecture
• La synchronisation présente plus qu'une simple
exclusion mutuelle
– sortie d'un bloc synchronisé : cache du thread courant
sauvé en mémoire partagé
– entrée dans un bloc synchronisé : les variables locales
du thread courant sont rechargées depuis la mémoire
partagée
www.objis.com
Java avancé
55
Apport Java 5
• Ce qui est visible par un thread A quand il écrit le
champ volatile le devient par le thread B quand il
lit ce même champ.
public class ExempleVolatile
{
int x=0;
volatile boolean v = false;
public void writer()
{
x=42;
v=true;
}
public void reader()
{
if(v)
{
// utilisation de x
}
}
}
www.objis.com
Java avancé
56
Utilitaires de gestion de concurrence
• Ensemble de classes et interfaces dans le package
java.util.concurrent
• Locks : Lock, ReadWriteLock, Condition
– possibilité de time-out, interruption
– condition multiples par verrou
– personnalisation de l'accès en verrou (read/write)
• Atomicité dans le package
java.util.concurrent.atomic
www.objis.com
Java avancé
57
Utilitaires de gestion de concurrence
• Collections thread-safe
– interface Queue et BlockingQueue
• Framework de séquenceur de tâches (task
scheduling)
– séquencement et contrôle des tâches asynchrones
– interfaces Callable, Future et Excecutor
• Sunchronisation
– Semaphore
– comte à rebours : CountDownLatch
www.objis.com
Java avancé
58
JavaFX : présentation
• JavaFX est une famille de produit ayant pour but
de créé des RIA (Rich Internet Application)
– Pour l'instant constitué de :
• JavaFX Script - langage de script utilisé pour la création de
composant swing
• JavaFX Mobile - environnement pour les plateformes
"mobile" qui supportent JavaFX
• Technologies concurrentes
– Flex - Adobe
– Silverlight - Microsoft
www.objis.com
Java avancé
59
JavaFX : présentation
• Simplification de la création de contenu
graphique
– animations
– changements de taille
– transparence
• Avantages
– basé sur Java (Java SE et ME)
– à terme utilisable sur tout écran : tv, navigateur,
mobile...
www.objis.com
Java avancé
60
JavaFX : présentation
www.objis.com
Java avancé
61