Discussion :

[dark0502]

Salut à tous,

Comme vous pouvez le voir ci-dessous, je me sers d'une variable booléenne 'stop' dans la méthode run de mon thread.

Quand je fais appel à la méthode stop, il met 'stop' à 'true' pour que l'exécution du run s'arrête.

Or, aussi vite que j'ai stoppé le thread, je refais appel à ma méthode start (le réappel à la méthode start n'est pas dans le code ci-dessous) qui remet cette variable booléenne à faux et démarre une nouvelle thread.

Le nouveau thread démarre mais l'ancien thread reste vivant car quand ce dernier a retesté la condition 'while (!stop)', il n'a pas pu se stopper étant donné que la variable booléenne a été changée trop rapidement.

J'ai déjà essayé dans ma méthode stop de faire un chrono.stop() mais elle est 'deprecated'.

J'espère avoir été assez clair. Avez-vous une solution?

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
package framework.business;
 
public class StopWatch implements Runnable {
    private int time;
    private boolean stop = false;
    private Thread chrono;
    private Engine engine;
 
    public StopWatch(Engine engine) {
        this.engine = engine;
    }
 
    public void run() {
        Avatar avatarToPlay = engine.getAvatarToPlay();
        GameBoard gameBoard = engine.getGame().getGameBoard();
        int nbGamePanel = gameBoard.getNbGamePanel();
 
        while (!stop) {
            try {
                Thread.sleep(1000);
                time--;
 
                for(int i = 0 ; i < nbGamePanel ; i++){
                    gameBoard.getGamePanel(i).refreshChrono(avatarToPlay,time);
                }
            } catch (InterruptedException e) {
 
            }
        }
    }
 
    public void start() {
        stop = false;
 
        chrono = new Thread(this);
        chrono.start();
    }
 
    public void stop() {
        stop = true;
    }
}

merci

[Ivelios]

Bonjour,

Quelle est la finalité du code?
Faire un chrono qui peut être mis en pause?
Le reste du code est un jeu vidéo je suppose?

Normalement, pour un jeu vidéo vous devez posséder un Thread Principal pour l'update des valeurs et un autre pour l'affichage.

Le theard du jeu ne doit JAMAIS s'arrêter sauf si le joueur quitte le jeu.
Votre Watch doit donc utiliser le Thread principal.
Comme ceci par 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
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
 
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class Game implements Runnable {
 
    private boolean stop;
    private boolean pause;
    private Watch watch;
    private JLabel label;
 
    public Game() {
        //Watch
        watch =new Watch();
 
 
        //Fenetre
        JFrame frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        JButton b = new JButton("Pause");
        label = new JLabel();
        b.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                if (pause == true) {
                    pause = false;
                } else {
                    pause = true;
                }
            }
        });
        JPanel p = new JPanel(new FlowLayout());
        p.add(b);
        p.add(label);
        frame.setContentPane(p);
        frame.setSize(new Dimension(200, 100));
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
 
 
        //Lance le thread
        new Thread(this).start();
    }
 
    public void run() {
 
        int delta = 2;
        while (!stop) {
            try {
                Thread.sleep(delta);
            } catch (InterruptedException e) {
            }
 
            if (!pause) {
 
                watch.update(delta);
                label.setText((int)watch.getTime()/1000+"");
            }
        }
    }
 
    public void setPause(boolean pause) {
        this.pause = pause;
    }
 
    public void setStop(boolean stop) {
        this.stop = stop;
    }
 
    public static void main(String[] args) {
        Game g = new Game();
 
 
    }
 
    private class Watch {
        private int time;
 
        public Watch(){
            time = 0;
        }
 
        public void update(float delta) {
            time+=delta;
        }
 
        public int getTime() {
            return time;
        }
    }
}

ps : J'ai fait des supposition et cela ne répond peut être pas à votre problème.

[tchize_]

au lieu de réutiliser votre Runnable, faites un nouveau Runnable.

[fallo]

tu peux partir sur l'idée que ton stop attends avant de rendre la main.

Code :

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

1
2
3
4
5
6
7
8
9
10
public synchronized void start() {
        stop = false;
         chrono = new Thread(this);
        chrono.start();
    }
 
    public synchronized void stop() {
        stop = true;
      /* if (chrono !=null) suggestion minimaliste, car il vaut mieu bien gerer l'etat avant*/  chrono.join(); 
    }

----

ou que ton start attends la fin de l'execution...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
private volatile boolean stop = false;  // volatile car l'appel de ton stop qui modifie le boolean est fait dans une autre thread.
....
public synchronized void start() {
       if (chrono != null)
       {
              chrono.join(/* eventuellement time out*/);
       }
       stop = false;
       chrono = new Thread(this);
       chrono.start();
    }

------

tu peux rajouter des interrupts -en plus - dans le stop pour demander au sleep de sortir (presque) immediatement.

---------
et mieux en général, et en appuyant la suggestion de "tchize_" tu peux passer par un service d'execution avec un seul thread a la fois (Executors.newSingleTrheadExecutor() de memoire) , et creer des FuturTask a partir du runnable, que tu pourras canceler un peu proprement ; tout en submitant celle venant ensuite.

-----
Bon courage.