Sommaire: Cours Java

I Threads
I.1 Modèle de threads de Java
I.2 Création et utilitaires
I.3 Synchronisation
I.4 Groupes de threads
I.5 États d’une thread et ordonnancement

II Génie logiciel appliqué
II.1 Implantation d’une pile en Java
II.2 Minimisation de couplage entre méthodes
II.3 Maximisation de cohésion des méthodes
III Programmation orientée objet en Java
III.1 Exemple 1 : balles
III.2 Exemple 2 : Flipper
III.3 Formes d’héritage
III.4 Exemple 3 : jeu de solitaire
IV Boîtes à outils awt et Swing
IV.1 Aperçu des classes
IV.2 Gestion des événements
IV.3 Gestionnaire de disposition
IV.4 Composants d’interface utilisateur spécifiquement Awt
IV.5 Un exemple
IV.6 Boîtes de dialogue
IV.7 Menus
V Classe Url
V.1 Classe URL
VI Paquetage java.net : Sockets
VI.1 Sockets : Rappels TCP/IP
VI.2 Sockets : Clients
VI.3 Sockets serveurs
VI.4 Serveurs itératifs
VI.5 Serveurs non bloquants
VI.6 Serveurs concurrents
VII Invotaion de méthodes distantes : RMI
VII.1 Notion d’invocation de méthode distante
VII.2 Sécurité – Sérialisation
VII.3 Brève description du fonctionnement des RM
VII.4 Implantation
VII.5 Paquetage java.rmi
VII.6 Paquetage java.rmi.registry
VII.7 Paquetage java.rmi.server
Bibliographie

Extrait du cours Java

I – Threads
I.1 Modèle de threads de Java
1.1 Threads et processus
– Le multi-tâches de threads occasionne bien moins de surcharge que le multitâches de processus
– Processus :
– Un ensemble de ressources ; par ex. sous UNIX, segment de code, de données utilisateur, de données systèmes (répertoire de travail, descripteurs de fichiers, identificateurs de l’utilisateur ayant lancé le processus, du groupe dont il fait partie, infos. sur l’emplacment des données en mémoire, . . . )
– Une unité d’exécution (avec, par ex. sous UNIX, des informations nécessaires à l’ordonnanceur, la valeur des registres, le compteur d’instructions, la pile d’exécution, des informations relatives aux signaux)
– Thread : on ne retient que l’aspect d’unité d’exécution.
– Contrairement aux processus, les threads sont légères :
– elles partagent le même espace d’adressage,
– elles existent au sein du même processus (lourd),
– la communication inter-thread occasionne peu de surcharge,
– le passage contextuel (context switching) d’une thread à une autre est peu coûteux.
1.2 Etats d’une thread
– Dans un environnement mono-thread, lorsqu’une thread se bloque (voit son exécution suspendue) en attente d’une ressource, le programme tout entier s’arrête. Ceci n’est plus le cas avec un environnement multi-threads
– Une thread peut être :
– en train de s’exécuter (running) ;
– prète à s’exécuter (ready to run), dès que la CPU est disponible ;
– suspendue (suspended), ce qui stoppe temporairement son activité ;
– poursuivre l’exécution (resumed), là où elle a été suspendue ;
– bloquée (blocked) en attendant une ressource.
Une thread peut se terminer à tout moment, ce qui arrête son exécution immédiatement. Une fois terminée, une thread ne peut être remise en route..
1.3 Priorités d’une thread
– Une thread peut
– soit volontairement laisser le contrôle. Ceci est réalisé en passant le contrôle explicitement, dormant ou bloquant en E/S. La thread prète à s’exécuter et de plus haute priorité est alors lancée.
– soit être supplantée par une autre de plus haute priorité. Si c’est systématiquement le cas, on parle de multi-tâches préemptif.
– Dans le cas où 2 threads de même priorité veulent s’exécuter, le résultat est dépendant du système d’exploitation (de son algorithme d’ordonnan-cement).
– Sous Windows 95, le même quantum de temps est tour à tour alloué aux threads de même priorité.
– Sous Solaris 2.x, des threads de même priorité doivent explicitement passer le contrôle à leurs pairs . . .
1.4 Synchronisation
– Synchronisation inter-threads via des moniteurs. Notion définie par C.A.R Hoare.
I.2 Création et utilitaires
2.1 Classe Thread et interface Runnable
– Le système de multi-threads de Java est construit autour de la classe Thread et de son interface compagnon Runnable.
– Liste des méthodes les plus courantes :
methode() But
getName() Obtenir le nom d’une thread
getPriority() Obtenir la priorité d’une thread
isAlive() Déterminer si une thread est toujours en
cours d’exécution
join() Attendre la terminaison d’une thread
resume() Poursuivre l’exécution d’une thread sus-
pendue
run() Point d’entrée (d’exécution) de la thread
sleep() Suspendre la thread pour une période de
temps donnée
start() Débuter une thread en appelant sa mé-
thode run()
suspend() Suspendre une thread
2.2 Création d’une thread
– Deux possibilités :
– Implanter l’interface Runnable,
– Créer une sous-classe de Thread
– Pour implanter Runnable, il y a seulement besoin d’implanter la méthode run() :
public abstract void run()
– Dans run(), on place les instructions de la thread à lancer.
– Ayant créé une classe implantant Runnable, on créé une instance de Thread dans cette classe :
Thread(Runnable objThread, String nomThread)
– La thread ne débute pas tant qu’on n’appelle pas start().
– En fait start() effectue un appel à run(). C’est un cadre logiciel.
synchronized void start()
class NouvelleActivite implements Runnable {
Thread th;
NouvelleActivite() {
th = new Thread(this, « Activite demo »);
System.out.println(« Activite enfant :  » + th);
th.start(); // Debuter l’activite
}
// Point d’entree de la nouvelle activite
public void run() {
try {
for(int i = 5; i > 0; i–) {
System.out.println(« Activite enfant :  » + i);
Thread.sleep(500);
}
} catch (InterruptedException e) {
System.out.println(« Enfant interrompu.);
}
System.out.println(« Sortie de l’activite enfant »);
}// run()
}// class NouvelleActivite
class ActiviteDemo {
public static void main(String args[]) {
new NouvelleActivite();
try {
for(int i = 5; i > 0; i–) {
System.out.println(« Activite parente :  » + i);
2.3 Création d’une thread : hériter de Thread
– Deuxième possibilité : créer une sous-classe de Thread, qui redéfinit la méthode run(). Même exemple :
class NouvelleActivite extends Thread {
NouvelleActivite() {
super(« Activite demo »);
System.out.println(« Activite enfant :  » + this);
start(); // Debuter l’activite
}
// Point d’entree de la nouvelle activite
public void run() {
try {
for(int i = 5; i > 0; i–) {
System.out.println(« Activite enfant :  » + i);
Thread.sleep(500);
}
} catch (InterruptedException e) {
System.out.println(« Enfant interrompu.);
}
System.out.println(« Sortie de l’activite enfant »);
}// run()
}// class NouvelleActivite
class ActiviteDemo {
public static void main(String args[]) {
new NouvelleActivite();
try {
for(int i = 5; i > 0; i–) {
System.out.println(« Activite parente :  » + i);
2.4 Méthodes utilitaires
– Ci-dessus figure sleep() :
static void sleep(long millisec) throws InterruptedException qui suspend l’exécution de la thread appelante pendant millisec milisecondes. Elle peut déclencher une exception
– Pour obtenir et changer le nom d’une thread, on dispose de :
final void setName(String nomThread)
final String getName()
– Deux moyens pour savoir quand une thread est terminée :
final boolean isAlive() throws InterruptedException qui renvoie true si la thread appelante est toujours en cours d’exécution ;
elle renvoie false sinon ;
final void join() throws InterruptedException qui attend que la thread appelante se termine.
– Suspension et poursuite d’exécution :
final void suspend()
final void resume()
– Obtention et modification de priorité : final void setPriority(int niveau) qui modifie la priorité à niveau, ce dernier étant entre MIN_PRIORITY et MAX_PRIORITY (qui sont souvent 1 et 10) ; la priorité par défaut est NORM_PRIORITY (généralement 5) ;
I.3 Synchronisation
3.1 Synchronisation
– Lorsque 2 threads ou plus ont besoin d’une même ressource au même moment, il y a besoin de s’assurer que la ressource ne sera utilisée que par une thread en même temps : on utilise alors un procédé de synchronistaion.
– Un moyen d’obtenir une synchronisation : les moniteurs.
– Un moniteur est un mécanisme utilisé comme un verrou d’exclusion mutuelle, un mutex.
– Lorsqu’une thread acquiert un verrou, on dit qu’elle entre dans le moniteur.
– Les autres threads sont dites en attente du moniteur.
– Analogie avec des cabines d’essayage de vêtements.
– Deux moyens de synchronisation : les méthodes synchronisées et les blocs synchronisés.
3.2 Méthodes synchronisées
– Pour entrer dans le moniteur d’un objet, appeler une méthode modifiée avec le mot clé synchronized.
– Lorsqu’une thread est dans une méthode synchronisée, toute autre thread qui essaie de l’appeler (elle ou toute autre méthode synchronisée) doit attendre.
– Pour sortir du moniteur, celui qui y est entré revient simplement de la méthode synchronisée.
– Exemple de programme non synchronisé. Dans une classe Callme, la méthode call() essaie d’afficher une chaîne String passée en paramètre et ce, entre crochets. Elle fait une pause d’une seconde ( sleep(1000)) entre la fin de la chaîne et le crochet fermant.
// Programme non synchronise
class Callme {
void call(String msg) {
System.out.print(« [ » + msg);

………
Si le lien ne fonctionne pas correctement, veuillez nous contacter (mentionner le lien dans votre message)
PDF Support de Cours Java (1116 KO) (Cours PDF)