Problème de Thread vivant

Version imprimable

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:

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

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:

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.

10/07/2011, 13h25
tchize_

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

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

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:

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.