TD1_CroupierControleur

TD control de processus # 1
2 – 02 – 2
Première partie
Nous allons montrer le séquençage des threads en considérant deux threads,
l'un instance de Croupier l'autre instance de Contrôleur.
Le boulot de chacun de ces deux spécialistes consiste en :
- Pour le croupier : Il est chargé de lancer une boule qui va tomber dans
une case colorée représentant un chiffre entre 0 et 9. A chaque lancé,
il inscrit le chiffre sorti dans un tableau. Au bout de N lancés il fait la
moyenne des chiffres sortis. La loi d'équiprobabilité de réalisation des
nombres doit donner comme moyenne 5.
- Le contrôleur est chargé de vérifier cette loi d'équiprobabilité. Il
récupère le tableau des N lancés et fait la moyenne des nombres
sortis. Celle-ci doit coïncider avec celle trouvée par le croupier.
En programmation procédurale, du fait de l’exécution séquentielle des
instructions, il faut que le croupier ait complètement rempli son tableau avant
que n'intervienne le contrôleur.
En programmation concurrente, si le croupier et le contrôleur sont des
instances de threads, il est possible que le contrôleur intervienne avant que le
tableau des nombres ne soit complètement rempli. Le résultat est alors
évidemment faux. Pour que le résultat soit correct, il faut que le controleur
utilise les cases du tableau une fois remplies.
Pour cela nous allons écrire un programme principal PP qui lit le nombre de
tirages Nbtirs à effectuer. Il réserve alors un tableau Tab[Nbtirs] de nombres
décimaux de type double. Les éléments de ce tableau sont par défaut remplis
par des 0.0.
Il lance alors successivement les threads croupier et contrôleur en passant à
chacun une référence à ce tableau Tab.

Les constructeurs de chacun des threads est de la forme:
Croupier(double tab[ ]) { ……… }
Controleur(double tab[ ]) { ……… }
Le croupier génère Nbtirs faux nombres aléatoires car tous égaux à 1.0. Il les
écrit dans un tableau Tab. A la fin de cette génération, il calcule la somme
de ces nombres et leur moyenne qui évidemment doit être égale à 1.0.
Il écrit sur l'écran le résultat trouvé.
Le contrôleur lit les Nbtirs éléments du tableau Tab, il en fait la moyenne qu'il
imprime.
Si les deux moyennes sont égales à 1.0, on peut dire que les deux threads ont
été bien synchronisés, dans le cas contraire, il faut vous même les
synchroniser.
Notes : La lecture d'un nombre entier entré au clavier peut prendre l'une des
formes suivantes :
1°) Invitation à entrer un nombre entier. Lecture et décodage de l'entier.
public class PP_invitation {
public static void main(String argv[ ]) {
int Nbtirs = 0; // Nbre de tirages à effectuer.
// Invitation à entrer le nbre de tirages à effectuer:
System.out.print("Entrer le nombre Nbtirs de tirages a executer : ");
// Création d'un BufferedReader pour lire un entier entré au clavier:
BufferedReader bfr = new BufferedReader(new InputStreamReader(System.in));
try {
// Lecture d'une chaine représentant le Nbre de tirages à effectuer:
String SNbTirs = bfr.readLine();
Nbtirs = Integer.parseInt(SNbTirs); // Transformation chaine <--> entier.
} catch(NumberFormatException nfe) { }
catch(IOException ioe) { }
System.out.println("Nbtirs = "+Nbtirs);
} // Fin de la méthode : public static void main(String [ ])
} // Fin de la classe : invitation

Exécution : java PP_invitation
Entrer le nombre Nbtirs de tirages a executer : 235
Nbtirs = 235
2°) Le nombre est entré sur la ligne de commande. Décodage de l'entier.
public class PP_decodageNbre { // Décodage entier entré sur ligne de commande
public static void main(String []argv) {
int Nbtirs = 0; // Nbre de tirages à effectuer.
// Recherche de la dimension de argv[]
int LgTabArgv = argv.length;
System.out.println("Dimension de arg[] : "+LgTabArgv);
// Impression des éléments argv[i]:
for(int i = 0; i<LgTabArgv; i++) System.out.println("argv["+i+"] : "+argv[i]);
// Transformation d'une chaîne en nbre entier:
try {
Nbtirs = Integer.parseInt(argv[0]);
} catch(NumberFormatException nfe) {
System.out.println("Exception: Erreur sur le format du nombre");
}
System.out.println("Nbtirs = "+Nbtirs);
} // Fin de la méthode : public static void main(String [ ])
} // Fin de la classe : PP_decodageNbre
Exécution : java PP_decodageNbre 678
Dimension de arg[] : 1
argv[0] : 678
Nbtirs = 678

Transformation du problème sous forme d'interface graphique utilisateur.
On crée un panel qui contient :
- des labels.
- des champs de texte (TextField) dans lequel des informations pourront être
introduites ou affichées.
- des boutons qui auront des actions spécifiques lorsqu'on cliquera dessus.
-
Voici un programme qui vous initie à l'écriture d'applications graphiques.
// Fichier ExempleGraphique.java
// Ce panel comporte les éléments standard suivants:
// 1°) un Label labPanel: qui représente le nom du panel considéré.
// 2°) un Label labType: qui représente le type du nom du label.
// 3°) un TextField fldNbTirs: pour écrire le nbre de tirages.
// 4°) un TextField fldMoy: pour écrire la moyenne des valeurs tirées.
// 5°) un Bouton Bset: qui finalise la valeurs écrite sur fldNbTirs.
// 6°) un Bouton BGo: qui lance une écriture sur fldMoy.
//
// Les clics sur les boutons sont écoutés par un Listener de nom ActionListener.
// ActionListener est une interface qui déclare une méthode unique :
// public void actionPerformed(ActionEvent e) qu'il faut implémenter.
import java.awt.*; // Pour utiliser les classes de awt.
import java.awt.event.*; // Pour le traitement des événements.
public class ExempleGraphique extends Panel implements ActionListener {
// Les champs de types primitifs:
int NBtirs = 10;
double Moyenne = 0.0;
// Les champs de types composants graphiques
private Label labPanel;
public Label labType;
private Label labNbTirs;
public TextField fldNbTirs;
private Label labMoy;
private TextField fldMoy;
public Button BSet, BGo;
//--- Constructeur ---//
public ExempleGraphique() {
// Disposition suivants 4 lignes et 2 colonnes des composants dans le Panel.
setLayout(new GridLayout(4,2));
// Création des instances des composants:
labPanel = new java.awt.Label("Panel"); // Création du label labPanel.

labType = new java.awt.Label("Type"); // Création du label labType.
labType.setForeground(Color.red); // Couleur de l'écriture.
labNbTirs = new java.awt.Label("Tirages"); // Création du label labNbTirs.
fldNbTirs = new java.awt.TextField("10", 20); // Création du TextField fldNbTirs.
labMoy = new java.awt.Label("Moyenne"); // Création du label labMoy.
fldMoy = new java.awt.TextField("", 20); // Création du TxtField fldMoy.
BSet = new java.awt.Button("Set"); // Création du bouton BSet.
BGo = new java.awt.Button("Go"); // Création du bouton BGo.
add(labPanel); // Ajoute ce label dans le panel.
add(labType); // Ajoute ce label dans le panel.
add(labNbTirs); // Ajoute ce label dans le panel.
add(fldNbTirs); // Ajoute ce TextField dans le panel.
add(labMoy); // Ajoute ce label dans le panel.
add(fldMoy); // Ajoute ce TextField dans le panel.
add(BSet); // Ajoute ce bouton dans le panel.
add(BGo); // Ajoute ce bouton dans le panel.
// Ajoute les Listeners sur les deux boutons:
BSet.addActionListener(this); // Listener sur Bouton BSet.
BGo.addActionListener(this); // Listener sur Bouton BGo.
} // Fin du constructeur
// Implémentation de la méthode: actionPerformed(ActionEvent) qui décrit
// les actions à effectuer lorsqu'on clique sur un bouton surveillé.
public void actionPerformed(ActionEvent ae) {
Object source = ae.getSource(); // Recherche le bouton source du clic
if (source.equals(BSet)) { // Action pour le bouton BSet
// Lire le contenu du Text Field fldNbTirs
String Texte = fldNbTirs.getText();
NBtirs = Integer.parseInt(Texte);
System.out.println("Nbre de Tirages NBtirs = "+NBtirs);
fldMoy.setText(String.valueOf(NBtirs));
}
else if (source.equals(BGo)) { // Action pour le bouton BGo
double Somme = 0.0;
// On tire NBtirs nombres au hasard grace à la fonction random de math:
for(int i=0; i< NBtirs; i++) Somme += Math.random();
Moyenne = Somme/NBtirs; // Calcul la moyenne des nbres aléatoires
fldMoy.setText(String.valueOf(Moyenne));
}
} // Fin de la méthode void actionPerformed(ActionEvent)
//---------------------------------------------------------------------------------------------------