Discussion :

[toitoine01]

Bonjour,

j'ai une programme multithread et j'ai un JTogglebouton pou effetuer une pause

dans mes classe qui gère les thread j'ai une méthode pause par laquelle je passe en paramètre l'etat de mon JTogglebouton :

Code :

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

1
2
3
4
5
6
7
 public void pause(clicpause)
{
if (clicpause)
t.suspend();
else
t.resume()
}

or ces deux méthode sont deprécie par java

comment faire justement pour pallier à ce probleme en utilisant la méthode sleep() ??????

car quand je l'utilise je suis obliger d'attendre X milliseconde avant que le programme reprenne alors que je voudrais qu'il reprenne dès que je clicque à nouveau sur pause

merci d'avance

@+

[ Modéré par Viena ]
Ajout balises de code : Pensez aux balises [code], votre message est plus lisible et la lecture plus facile.
Les Règles du Forum

[cladsam]

Bonjour,
dans ton message,
ou est la question?

[toitoine01]

désolé erreur de manip j'avais pas fini d'ecrire le message je l'avais valider par erreur

désolé

[cladsam]

http://java.developpez.com/faq/java/...angage_threads

[toitoine01]

merci mais cela ne ressoud pas mon problème

le problème reste que je suis obliger d'attendre le temps passer en paramètre dans mon sleep() alors que je veut reprendre l'excecution du thread des que je reclic sur pause

je clicque une fois le thread se met en pause
je reclcique le thread reprends son excution et ainsi de suite

je veut avoir la main sur la pause

cordialement

[BizuR]

ya pas moyen de jouer avec les méthodes wait() et signal() ?
L'une va déclencher l'attente et l'autre déclenchera la reprise avec signal() ...

Enfin, c'est une suggestion, je n'ai jamais essayé et j'ai utilisé ces deux méthodes uniquement dans le cadre de l'exclusion mutuelle ... pas de l'attente (donc, par exemple, je ne sais pas si un thread qui attend, peut se reveiller lui même, etc...) ou bien les mettre en file d'attente et emettre le signal uniquement au thread concerné par la pause à partir de ton gestionnaire de thread ... enfin bref, à approfondir je dirai !

[cladsam]

Ca resoud ton probleme dans le sens ou il y a de sliens sur la programmation des Threads vers des cours qui doivent surement exposé ton probleme assez courant (javais eu pareil uen fois avec un jeu de la vie en graphique)

[Razgriz]

Ca ça marche bien pour faire des pauses

Code :

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

1
2
3
4
5
6
7
8
9
10
 
if(bouton cliqué)
{
     try
     {
          Thread.sleep(1L); //fais stoper une milliseconde (L car le type est long)
     }
      catch(InterruptedException e)
      {}
}

[adiGuba]

Salut,


Si les méthodes resume() et suspend() sont dépréciée, c'est que ton application peut se retrouver dans un état incohérent lorsque le thread est suspendu pendant certain traitement... ce qui peut te poser d'autres problèmes dans d'autres threads (et il est souvent pas évident du tout de retrouver l'origine du problème).

La solution alternative est donc d'utiliser des wait()/notify() comme l'as indiqué BizuR, et cela implique que le thread n'est pas vraiment mis en pause au moment même où tu appelleras la méthode pause(), mais c'est plutôt ce dernier qui vérifiera de temps en temps s'il doit se mettre en pause...

Cela pourrait donner pour un traitement en boucle :

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
public class Traitement extends Thread {
 
    boolean isPaused = false;
 
    public void run() {
        while (true) {
            // Traitement ...
            // ...
 
            // On vérifie si l'on doit se mettre en pause ou pas...
            checkPause();
        }
    }
 
    public synchronized void pause(boolean bValue) {
        this.isPaused = bValue;
        if (!this.isPaused) {
            // Lorsqu'on sort de la pause,
            // On notifie le thread pour qu'il sorte de son attente.
            this.notify();
        }
    }
 
    private synchronized void checkPause() {
        // Le while est requis pour éviter les "faux-réveil"
        while (this.isPaused) {
            try {
                // On endors le thread courant
                this.wait();
            } catch (InterruptedException e) {
                // Interruption (ignoré)
                // A traiter si on veux également gérer les interruptions
            }
        }
    }
}

Dans la méthode run(), on fait un ou plusieurs appel à checkPause() pour vérifier si l'on doit se mettre en pause ou pas. Ainsi le thread ne risque pas de se retrouver bloquer dans un état incohérent...

a++

[toitoine01]

Merci pour ces réponses une dernière question cependant

lorsque l'on synchronize des thread c seulement dans le cas où chaque thread accède à la même donné

alors que dans mon cas chaque thread à une donnée propore meme si c donné ont la meme valeur

donc peut ton utiliser la synchronization?

Merci