Discussion :

[Cisman]

Bonjour, j'ai un exercice dont l’énoncé est le suivant:

Développer un programme de jeux automatique qui consiste à effectuer pour chaque joueur, 10 itérations ayant chacune un temps aléatoire.

La finalité de ce jeux est d'établir un classement des joueurs par ordre croissant du temps total.


Les directives pour créer ce jeu sont :


minimum 4 joueurs ayant comme identifiant un prénom (choisir des prénoms différents)

le temps aléatoire pour chaque itération est compris entre 0 et 5000 mSec

le temps aléatoire est créé via la méthode Math.random() (voir javadoc)

pour chaque joueur et après chaque itération, afficher le nom du joueur et le temps de l'itération

le lancement du comptage pour chaque joueur est effectué lors du démarrage du programme


Dans un premier temps :


afficher le nom du joueur et son temps total après ses 10 itérations


Dans un deuxième temps :


utiliser un thread deamon qui gère l'affichage du classement

ce thread peut gérer un nombre indéterminé de joueurs

lorsque tous les joueurs ont terminé leurs itérations, le classement par ordre croissant de temps est affiché

l'affichage contient le nom du joueur et son temps total


Class Starter

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
package be.iepscfjemelle.poolabo.controller;
 
import be.iepscfjemelle.poolabo.model.Joueur;
import java.util.HashMap;
 
/**
 *
 * 
 */
public class Starter {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
        int nbJoueur;
        HashMap<String, Double> mapClassement = new HashMap<>();
 
        System.out.println("Veuiller entrer le nombre de joueurs: ");
        nbJoueur = Clavier.lireInt();
 
        for (int i = 1; i <= nbJoueur; i++) {
            System.out.println("Entre le prénom du joueur " + i);
            //Joueur ji = new Joueur(Clavier.lireString());    
            mapClassement.put(Clavier.lireString(), 0.0);   
            Joueur ji = new Joueur(Clavier.lireString());
            ji.start();
        }
    }
}

Class Joueur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
package be.iepscfjemelle.poolabo.model;
 
/**
 *
 * 
 */
public class Joueur implements Runnable{
 
    private String prenom;
 
    public Joueur() {
    }
 
 
 
    public Joueur(String prenom) {
        this.prenom = prenom;
    }
 
    public String getPrenom() {
        return prenom;
    }
 
    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }
 
    @Override
    public void run() {
        Double lower = 0.d;
        Double higher = 5.0d;
        Double tempsAleatoire;
        Double tempsTotal = 0.d;
 
        for (int i = 0; i < 10; i++) {
            tempsAleatoire = (Math.random() * (higher - lower)) + lower;
            System.out.println(getPrenom() + " : " + "Temps aleatoire = " + tempsAleatoire);
            tempsTotal = tempsTotal + tempsAleatoire;
            if (i==10){
                System.out.println(getPrenom() + " : " + "Temps total = " + tempsTotal);
            }
 
        } 
 
    }
 
    public void start() {
        Thread t = new Thread(this);
        t.start();
    }
}

Pour le moment, j'en suis au premier temps.
Quel collection utiliser pour y mettre [prénom joueur][temps aléatoire] et surtout pouvoir récupérer le résultat d'après le nom ou index?
De plus est-ce une bonne pratique d'utiliser ma classe Joueur comme Thread (ici Runnable)?, j"ai ma réponse, une classe joueur, un thread compteur, un thread deamon pour calculer le temps total par joueur.
En fait, je ne maitrise pas trop les collections et j'ai du mal à trouver une bonne structure à mon programme (diagramme de classe)

[Pill_S]

De plus est-ce une bonne pratique d'utiliser ma classe Joueur comme Thread (ici Runnable)?

Ce n'est une bonne idée que si la notion de "tâche exécutable" est profondément liée au concept de "Joueur". Réponse: dans ton cas c'est probablement pas une excellente idée.

En fait, je ne maitrise pas trop les collections

Alors, mieux vaut commencer par là (c'est vraiment la base et coder sans comprendre le framework collection c'est une perte de temps).

Commence par faire des essais dans un projet vide, pour comprendre les bases et acquérir les compétences nécessaires. Tu verras, c'est vraiment pas compliqué.

[Cisman]

Merci pour ta réponse.

J'ai utilisé des tableaux pour finir.
Je ne voyais pas comment avec des collections instancier plusieurs objets joueur numérotés. (joueur1, joueur2, etc...).

J'ai un autre soucis de Thread, celui-ci fonctionne et fait ce que je veux, c'est à dire sortie 10 nombre aléatoire. Je voudrais bien récupérer à chaque boucle le nombre aléatoire et le placer dans l'attribut tempsAleatoire d'un joueur. Est-ce possible vu que la méthode run() ne prend rien en paramètre et ne renvoi rien?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class Starter {
 
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
 
        GestionEntites controller = new GestionEntites();
        controller.execute();
    }
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public class GestionEntites {
 
    public void execute() {
 
        int nbjoueur;
        System.out.println("Veuiller entrer le nombre de joueurs: ");
        nbjoueur = Clavier.lireInt();
 
        Joueur[] tabjoueur = new Joueur[nbjoueur];
        CompteurAleatoire[] tabthread = new CompteurAleatoire[nbjoueur];
 
        for (int i = 1; i <= nbjoueur; i++) {      
            System.out.println("Entre le prénom du joueur " + i);
            tabjoueur[i-1] = new Joueur(Clavier.lireString()); 
            //tabjoueur[i-1].setTempsAleatoire(Double.MAX_VALUE) = new CompteurAleatoire();
            tabthread[i-1] = new CompteurAleatoire(tabjoueur[i-1]);        
        }
 
        for (int i = 1; i <= nbjoueur; i++){
            tabjoueur[i-1].setTempsAleatoire(Double.MAX_VALUE); 
            tabthread[i-1].start(tabjoueur[i-1]);
        }
}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
public class Joueur {
 
    private String prenom;
    private Double tempsAleatoire;
    private Double tempsTotal;
 
    public Joueur(String prenom) {
        this.prenom = prenom;
    }
 
    public Joueur(String prenom, Double tempsAleatoire) {
        this.prenom = prenom;
        this.tempsAleatoire = tempsAleatoire;
    }
 
    public Joueur() {
 
    }
 
    public String getPrenom() {
        return prenom;
    }
 
    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }
 
    public Double getTempsAleatoire() {
        return tempsAleatoire;
    }
 
    public void setTempsAleatoire(Double tempsAleatoire) {
        this.tempsAleatoire = tempsAleatoire;
    }
 
    public Double getTempsTotal() {
        return tempsTotal;
    }
 
    public void setTempsTotal(Double tempsTotal) {
        this.tempsTotal = tempsTotal;
    }
 
    public void start() {
        Thread t = new Thread((Runnable) this);
        t.start();
    }
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
public class CompteurAleatoire implements Runnable {
 
    public CompteurAleatoire() {
 
    }
 
    public CompteurAleatoire(Joueur joueur) {
 
    }
 
    public Joueur CompteurAleatoire(Joueur joueur) {
        return joueur;
 
    }
 
    @Override
    public void run() {
        Double lower = 0.d;
        Double higher = 5.0d;
        Double tempsAleatoire;
        //Double tempsTotal = 0.d;
 
        for (int i = 0; i < 10; i++) {
            Joueur j = new Joueur();
            tempsAleatoire = (Math.random() * (higher - lower)) + lower;
            System.out.println(j.getPrenom() + " : " + "Temps aleatoire = " + tempsAleatoire);
            /*tempsTotal = tempsTotal + tempsAleatoire;
            if (i==10){
                System.out.println(j.getPrenom() + " : " + "Temps total = " + tempsTotal);
            }*/
        }
    }
 
    public Joueur start(Joueur joueur) {
        Thread t = new Thread((Runnable) this);
        t.start();
        return joueur;
    }
}

[Pill_S]

J'ai utilisé des tableaux pour finir.
Je ne voyais pas comment avec des collections instancier plusieurs objets joueur numérotés. (joueur1, joueur2, etc...).

Une collection (ou plutôt une List), ça peut être vu comme un tableau "intelligent" (qui sait se redimensionner tout seul lorsque nécessaire, qui gère lui même le shifting lorsque l'on supprime un élément au milieu, etc.). Tout ce que tu peux faire avec un tableau, tu peux le faire plus facilement avec une List. Rapide exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
Joueur[] tabjoueur = new Joueur[nbjoueur];
CompteurAleatoire[] tabthread = new CompteurAleatoire[nbjoueur];
 
for (int i = 1; i <= nbjoueur; i++) {      
    System.out.println("Entre le prénom du joueur " + i);
    tabjoueur[i-1] = new Joueur(Clavier.lireString()); 
    //tabjoueur[i-1].setTempsAleatoire(Double.MAX_VALUE) = new CompteurAleatoire();
    tabthread[i-1] = new CompteurAleatoire(tabjoueur[i-1]);        
}
 
// pourrait s'écrire:
List<Joueur> tabjoueur = new ArrayList<>(nbjoueur);
List<CompteurAleatoire> tabthread = new ArrayList<>(nbjoueur);
 
for (int i = 0; i < nbjoueur; i++) { // prends l'habitude de boucler depuis 0 et pas 1, c'est plus "naturel"      
    System.out.println("Entre le prénom du joueur " + (i+1));
    tabjoueur.add(new Joueur(Clavier.lireString())); 
    tabthread.add(new CompteurAleatoire(tabjoueur.get(i)));        
}

J'ai un autre soucis de Thread, celui-ci fonctionne et fait ce que je veux, c'est à dire sortie 10 nombre aléatoire. Je voudrais bien récupérer à chaque boucle le nombre aléatoire et le placer dans l'attribut tempsAleatoire d'un joueur. Est-ce possible vu que la méthode run() ne prend rien en paramètre et ne renvoi rien?

Alors déjà normalement, c'est jamais toi qui invoque run. Tu invoques start, et le système d'exploitation va créer un thread que la JVM ordonnencera ensuite. Mais si tu invoques run toi-même, alors tu ne lances pas vraiment un thread séparé mais tu l'exécute dans le thread courant.

Ensuite, rien n'empêche d'utiliser des arguments lors de la création du thread. Du style:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
class AfficherCaractèreThread extends Thread {
    private final char which;
    private final int howMany, delay;
 
    public AfficherCaractèreThread(char which, int howMany, int delay) {
        this.which = which;
        this.howMany= howMany;
        this.delay= delay;
    }
 
    @Override
    public void run() {
        for(int i=0; i<howMany; i++) {
            System.out.println(which);
 
            try { Thread.sleep(delay);} catch(InterruptedException e) { Thread.currentThread().interrupt(); }
        }
    }
}
 
Thread t1 = new AfficherCaractèreThread('a', 5, 100);
Thread t2 = new AfficherCaractèreThread('b', 10, 80);
Thread t3 = new AfficherCaractèreThread('c', 2, 852);
 
t1.start();
t2.start();
t3.start();
 
t1.join();
t2.join();
t3.join();

... de cette façon tu personnalise ton thread sans nécessiter de paramètres dans la méthode run. Là j'ai passé des primitifs à la construction du thread, mais rien n'empêche de passer des objets mutables qui peuvent être altérés par l'exécution de la méthode run.

J'espère que ça va t'aider

[Cisman]

Merci pour tes précieux conseils.

Pour le Thread, j'ai créé une méthode play(), c'est elle qui génère les 10 nombres aléatoire, c'est cette méthode que j’appel dans le run() de mon Thread.
Entre temps, j'avais trouve une solution avec deux arraylist, une pour y placer mes joueurs et une pour y placer les résultats de mon Thread, les temps aléatoire.
Le problème que j'ai maintenant, c'est arriver à faire correspondre un joueur avec ses 10 temps aléatoire et afficher les 10 temps aléatoire de chaque joueur. le nombre d'index de l'Arraylist de mes joueurs (4 joueurs) ne correspond pas forcément au nombre d'index de mon ArrayLIst tempsAléatoire (10 temps).

Class GestionEntités

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
public class GestionEntites {
 
    public void execute() {
 
        ArrayList<Joueur> tabjoueur = new ArrayList<>();
        int nbjoueur;
 
        System.out.println("Veuiller entrer le nombre de joueurs: ");
        nbjoueur = Clavier.lireInt();
 
        for (int i = 1; i <= nbjoueur; i++) {
            Joueur joueur = new Joueur();
            System.out.println("Entre le prénom du joueur " + i);
            joueur.setPrenom(Clavier.lireString());
            tabjoueur.add(joueur);
        }
 
        tabjoueur.forEach((j) -> {
            System.out.println(j.getPrenom() + ":");
 
        });
 
        for (int i = 1; i <= nbjoueur; i++) {
            CompteurAleatoire thread = new CompteurAleatoire();
            thread.start();
            Double tempaleatoire = play();
            if (thread.isAlive()) {
 
            }
        }
 
    }
 
    public Double play() {
        Double lower = 0.d;
        Double higher = 5.0d;
        Double tempsaleatoire = null;
        for (int i = 0; i < 10; i++) {
            Joueur j = new Joueur();
            tempsaleatoire = (Math.random() * (higher - lower)) + lower;
            //System.out.println(j.getPrenom() + " : " + "Temps aleatoire = " + tempsAleatoire);
 
        }
        return tempsaleatoire;
    }
 
}

Class Joueur

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
public class Joueur implements Comparable<Object>{
 
    private String prenom;
    ArrayList<Double> listTemps = new ArrayList<>();
    private Double tempsTotal;
 
    public Joueur(String prenom) {
        this.prenom = prenom;
    }
 
    public Joueur(String prenom, Double tempsTotal) {
        this.prenom = prenom;
        this.tempsTotal = tempsTotal;
    }
 
    public Joueur() {
 
    }
 
    public String getPrenom() {
        return prenom;
    }
 
    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }
 
    public ArrayList<Double> getListTemps() {
        return listTemps;
    }
 
    public void setListTemps(ArrayList<Double> listTemps) {
        this.listTemps = listTemps;
    }
 
    public Double getTempsTotal() {
        return tempsTotal;
    }
 
    public void setTempsTotal(Double tempsTotal) {
        this.tempsTotal = tempsTotal;
    }
 
    @Override
    public int compareTo(Object j) {
        return 0;  
    }
 
 
 
 
    void update() {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }
 
}

Class Thread

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
public class CompteurAleatoire extends Thread{
 
    public CompteurAleatoire() {
 
    }
 
    GestionEntites p = new GestionEntites();
 
    @Override
    public void run() {
        p.play();
 
        //Double tempsTotal = 0.d;
 
 
            /*tempsTotal = tempsTotal + tempsAleatoire;
            if (i==10){
                System.out.println(j.getPrenom() + " : " + "Temps total = " + tempsTotal);
            }*/
        }
    }

[Pill_S]

le nombre d'index de l'Arraylist de mes joueurs (4 joueurs) ne correspond pas forcément au nombre d'index de mon ArrayLIst tempsAléatoire (10 temps).

Alors il faut probablement utiliser un autre type de structure de données: les Map

Une map - qui fait presque partie du framework Collection - fait correspondre une clé à une valeur.

La clé, c'est le joueur, la valeur, c'est la liste des temps qui lui correspondent. ça pourrait s'utiliser comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
Map<Joueur, List<Long>> joueurToTimesMap = new HashMap<>();
...
Joueur j1 = ...
List<Long> timesForJ1 = new ArrayList<>();
timesForJ1.add(123);
timesForJ1.add(456);
timesForJ1.add(789);
map.put(j1, timesForJ1);
...
List<Long> timesForJ1 = map.get(j1);
...

Attention cependant, les HashMap (tout comme les HashSet ou n'importe quelle structure de données exploitant le hashCode), impliquent une implémentation correcte des méthodes equals et hashCode pour la classe qui sert de clé. Sinon, le comportement est indéterminé.

[Cisman]

J'ai déjà utilisé une hashMap avec ses méthode hashCode et equals, pour éviter les doublons.
Par contre, une List dans une Map, je n'y avait pas pensé.

Une question, je peux lancer mon Thread en le passant comme paramètre à la méthode add(thread.start())?
Pcq, pas moyen, j'ai une erreur "void type not allowed here"

Je ne sais pas si ici, c'est ma méthode play qui me renvoi un Double ou la méthode run() de mon thread qui ne renvoi rien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
public class GestionEntites {
 
    public void execute() {
 
 
        HashMap<Joueur, ArrayList<Double>> joueurToTimesMap = new HashMap<>();
        int nbjoueur;
 
        System.out.println("Veuiller entrer le nombre de joueurs: ");
        nbjoueur = Clavier.lireInt();
 
        for (int i = 1; i <= nbjoueur; i++) {
            Joueur joueur = new Joueur();
            ArrayList<Double> timeForJ = new ArrayList<>();
            System.out.println("Entre le prénom du joueur " + i);
            joueur.setPrenom(Clavier.lireString());
 
            CompteurAleatoire thread = new CompteurAleatoire();
 
            timeForJ.add(thread.start());
            joueurToTimesMap.put(joueur, timeForJ);
        }
 
        /*tabjoueur.forEach((j) -> {
            System.out.println(j.getPrenom() + ":");
 
        });*/
 
    }
 
    /**
     * Méthode play, qui génère un tempsaléatoire et renvoi ce temps aléatoire
     * @return 
     */
    public Double play() {
        Double lower = 0.d;
        Double higher = 5.0d;
        Double tempsaleatoire = null;
        for (int i = 0; i < 10; i++) {
            Joueur j = new Joueur();
            tempsaleatoire = (Math.random() * (higher - lower)) + lower;
            //System.out.println(j.getPrenom() + " : " + "Temps aleatoire = " + tempsAleatoire);
 
        }
        return tempsaleatoire;
    }
 
    public void update() {
        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
    }
 
}

Attention cependant, les HashMap (tout comme les HashSet ou n'importe quelle structure de données exploitant le hashCode), impliquent une implémentation correcte des méthodes equals et hashCode pour la classe qui sert de clé. Sinon, le comportement est indéterminé.[/QUOTE]

[Pill_S]

Une question, je peux lancer mon Thread en le passant comme paramètre à la méthode add(thread.start())?
Pcq, pas moyen, j'ai une erreur "void type not allowed here"

Oui c'est normal, start() telle qu'elle est définie dans la classe Thread, ne retourne aucun résultat et ne prend pas de paramètres.

[Cisman]

Voilà la solution à mon problème.
Pour finir, que deux collection (ArrayList), une pour mes joueurs, l'autre pour mes Threads.
J'affiche bien chaque temps aléatoire avec son joueur, mais j'ai encore un soucis pour lancer mon daemon quand les threads.is Interrupted, il ne se passe rien.
De plus, est-ce que Collections.sort(mon Arraylist) fonctionnera comme ça en sachant que je veux la trier dans l'ordre croissant sur base du tempsTotal, ou, c'est mieux d'implémenter la méthode compareTo()?

Voici mon code:

Class Partie:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
public class Partie {
 
    public void execute() {
 
        int nbJoueurs;
        ArrayList<Thread> threads = new ArrayList<>();
        ArrayList<Joueur> joueurs = new ArrayList<>();
 
        System.out.println("Veuillez entrer le nombre de joueurs:");
        nbJoueurs = Clavier.lireInt();
 
        for (int i = 0; i < nbJoueurs; i++) {
            System.out.println("Veuillez entrer le prenom du joueur " + (i + 1));;
            Joueur joueur = new Joueur(Clavier.lireString());
            joueurs.add(joueur);
            Thread classement = new Classement(joueurs, joueur);
            Thread thread = new JoueurThread(joueur);
            threads.add(thread);
            thread.start();
            if (thread.isInterrupted()) {
                classement.setDaemon(true);
                classement.start();
            }
        }
        /*
        // Deuxième étape
        Thread afficheClassement = new Thread(() -> {
            // Attend qu'ils soient tous arrivés
            for (Thread thread : threads) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
 
            joueurs.sort((joueur1, joueur2) -> (int) (joueur1.getTempsTotal() - joueur2.getTempsTotal()));
 
            System.out.println("Classement final :");
 
            for (Joueur joueur : joueurs) {
                System.out.format("%s : %d%n", joueur.getPrenom(), joueur.getTempsTotal());
            }
        });
 
        afficheClassement.start();*/
    }
 
}

Ma classe Joueur:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
public class Joueur {
 
    private final String prenom;
    private long tempsTotal;
    private boolean estArrive = false;
 
    public Joueur(String prenom) {
        this.prenom = prenom;
    }
 
    public String getPrenom() {
        return prenom;
    }
 
    public long getTempsTotal() {
        return tempsTotal;
    }
 
    public void setTempsTotal(long tempsTotal) {
        this.tempsTotal = tempsTotal;
    }
 
    public boolean getEstArrive() {
        return estArrive;
    }
 
    public void setEstArrive(boolean estArrive) {
        this.estArrive = estArrive;
    }
 
}

Ma classe Thread:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
public class JoueurThread extends Thread {
 
    private final Joueur joueur;
 
    public JoueurThread(Joueur joueur) {
        this.joueur = joueur;
    }
 
    @Override
    public void run() {
 
        for (int i = 0; i < 10; i++) {
            long tempsAleatoire = (long) (Math.random() * 5000);
            joueur.setTempsTotal(joueur.getTempsTotal() + tempsAleatoire);
 
            try {
                    Thread.sleep(tempsAleatoire);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            // Première étape
            System.out.format("%s : %d%n", joueur.getPrenom(), tempsAleatoire);
 
        }
 
 
 
    }
 
}

Ma classe Classement Thread que je lanc comme daemon:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
public class Classement extends Thread {
 
    private final ArrayList list;
    private final Joueur joueur;
 
    public Classement(ArrayList list, Joueur joueur) {
        this.list = list;
        this.joueur = joueur;
    }
 
    @Override
    public void run() {
        while (true) {
            afficheClassement(list, joueur);
        }
    }
 
    public void afficheClassement(ArrayList list, Joueur joueur) {
        Collections.sort(list);
        System.out.println("Classement final :");
        for (Iterator it = list.iterator(); it.hasNext();) {
            Joueur j = (Joueur) it.next();
            System.out.format("%s : %d%n", joueur.getPrenom(), joueur.getTempsTotal());
        }
    }
 
}