Thread, Arrête toi je le veux !

**mlle lain** · 11/10/2006, 16h08

Bonjour,
J'aime pas les threads j'y comprend rien.
Aidez-moi

J'ai une gentille appli avec une belle interface graphique. A moment donné, un click vigoureux sur un bouton lance dans un thread un processus de génération complexe et long et dans un autre une barre de progression. Je veux qu'en clickant sur un bouton, je puisse stoper les deux.
J'ai lu toute la doc que j'ai pu trouvé sur le sujet et je n'en regrette que plus stop() et destroy()

Je ne comprends pas comme stopper ce Thread. Voici la fonction qui lance le thread de génération

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
      private void compute() {
            progressBar = new Barre();  
            flag = true;
            File tmpFile = null;
        if (!((JEditArea)tabbedPane.getSelectedComponent()).isSaved()){                            
            int n = JOptionPane.showOptionDialog(this,
                "<html> Your file is unsaved. <br> Would you want to save it ?</html>",
                "Warning",
                JOptionPane.YES_NO_OPTION,
                JOptionPane.WARNING_MESSAGE,
                null,
                options,
                options[0]); 
            if (n==JOptionPane.YES_OPTION){
                saveAsFile(); 
                currentFile = ((JEditArea)tabbedPane.getSelectedComponent()).getFile();
            } else { // creation du fichier temp
                                          

                currentFile = ((JEditArea)tabbedPane.getSelectedComponent()).createTempfile();   
            }
        } else {
            try {
                currentFile = ((JEditArea)tabbedPane.getSelectedComponent()).getFile();
            } catch (NullPointerException npe) {
                System.out.println("Null Pointer Exception");
            }
        }   
         
        (new Thread() {   
            public void run() {
                
                    
                while (flag) {                   
                try {                    
                    File file = getCurrentFile();
                    TestParser testParser = new TestParser();             
                    if (file.canRead()){                        
                        try {
                            testParser.process(file);
                            stopBar();
                            displayInfo("ICAr generate with sucess");        
                        } catch (cdi.amparser.HandlerException he) {
                            System.out.println(he.getMessage());
                            he.printStackTrace();
                            stopBar();
                            displayInfo("Compilation Error");    
                        }
                        catch (Exception e) {
                        System.out.println(e.getMessage());
                        stopBar();
                        displayInfo("Compilation Error");  
                        
                    }
                }
              } catch (NullPointerException npe) {
                stopBar();               
           }                              
      
            }
            }
             
        }).start();  
       try {
            tmpFile.delete();
       } catch (NullPointerException npe) {}
    }

(Le while marche pas bien evidemment je le sais bien)
Merci d'avance (encore)

Lain

**BainE** · 11/10/2006, 16h15

ben quand tu va passer ton flag a "false", ton thread va sortir de la boucle et executer les instructions qui suivent puis se terminer.

Ca ne te va pas comme ca ?

**mlle lain** · 11/10/2006, 16h33

Ben non.
Pourquoi mon Thread bouclerait avant la fin ? Il boucle pas.
Il fait gentiment toutes ces instructions sequentielement.
Le while est une solution que j'ai trouvé de ci de là mais c'est bon que pour les process de type Timer ... :-(
Je veux l'interrompre au milieu de la séquence.

**BainE** · 11/10/2006, 16h44

a la premiere ligne je vois :
while( flag )

et il boucle pas ?
tu peux tester l'intruction critique par un if(flag) exec...
tu inhibes l'instruction comme ca, apres les quelques instructions executées ne vont pas ralentir le process...
Sinon je ne vois pas

**mlle lain** · 11/10/2006, 16h53

Oublie le while

Il boucle dans la mesure où une boucle boucle

Mais moi je veux le stopper AVANT la fin de l'itération !

**mlle lain** · 11/10/2006, 17h32

Y aurait-il moyen que je m'en sorte en utilisant la classe Runtime plutôt qu'un Thread ?

**®om** · 11/10/2006, 18h29

Non, tu dois forcément finir ton traitement (donc tu fais des if(isInterrupted()) de temps en temps entre 2 traitements de temps en temps, pour lui donner des points où il peut s'arrêter...)...

**mlle lain** · 12/10/2006, 09h20

Bonjour,
Ralalala mais ca me va pas du tout moi comme solution.
Le traitement c'est juste un appel à une fonction d'une autre classe que je ne fais qu'utiliser ("pas toucher, mlle lain, pas toucher !!"). Si je l'ai flanquée dans un "Thread" c'est bien justement dans l'intention de pouvoir la killer n'importe quand !!! Ces traitements peuvent prendre des heures !!
Ne me dites pas que je ne peux pas faire l'équivalent d'un bon kill -9 en Java ?????

**®om** · 12/10/2006, 09h46

Envoyé par mlle lain

Bonjour,
Ralalala mais ca me va pas du tout moi comme solution.
Le traitement c'est juste un appel à une fonction d'une autre classe que je ne fais qu'utiliser ("pas toucher, mlle lain, pas toucher !!"). Si je l'ai flanquée dans un "Thread" c'est bien justement dans l'intention de pouvoir la killer n'importe quand !!! Ces traitements peuvent prendre des heures !!
Ne me dites pas que je ne peux pas faire l'équivalent d'un bon kill -9 en Java ?????

Durant le traitement, tu peux faire un test et renvoyer une exception InterruptedException, ce qui terminera ta méthode run... (avec éventuellement un try catch)...

**schniouf** · 12/10/2006, 09h53

Envoyé par ®om

Durant le traitement, tu peux faire un test et renvoyer une exception InterruptedException, ce qui terminera ta méthode run... (avec éventuellement un try catch)...

Justement, son soucis c'est qu'elle appelle une seule fonction hyper longue. Donc pas moyen de faire des tests d'interruption, si j'ai bien compris. Ca doit ressembler à ça :

Code :

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

1
2
3
public void run() {
   fonctionHyperLongue() ;
}

Y'a pas moyen de mettre de tests là dedans, à moins d'en insérer dans fonctionHyperLongue() justement. Mais comme elle a pas le droit de la modifier... je sais pô...

**mlle lain** · 12/10/2006, 10h06

Bon au moins on se comprend

Effectivement, je veux/dois pas toucher à FonctionHyperLongue() mais de toute façon, je pourrais, ca me satisferait pas non plus car dans FonctionHyperLongue() y a des appels à ParsingHyperLong(), AnalyzingMegaComplexe(), CodageMoyenLong et PackagingPasCourt().
Alors avec des tests sur un flag entre chaque appel aux fonctions par exemple, j'aurais le temps de boire un café et de refaire le monde avec les collègues avant que mon click sur le bouton "STOP" ait un effet ....

Je trouve abérrant que ce soit si dur de trouver une solution à ça ...

**schniouf** · 12/10/2006, 11h36

Envoyé par mlle lain

Bon au moins on se comprend

Effectivement, je veux/dois pas toucher à FonctionHyperLongue() mais de toute façon, je pourrais, ca me satisferait pas non plus car dans FonctionHyperLongue() y a des appels à ParsingHyperLong(), AnalyzingMegaComplexe(), CodageMoyenLong et PackagingPasCourt().
Alors avec des tests sur un flag entre chaque appel aux fonctions par exemple, j'aurais le temps de boire un café et de refaire le monde avec les collègues avant que mon click sur le bouton "STOP" ait un effet ....

Je trouve abérrant que ce soit si dur de trouver une solution à ça ...

Ben alors faut aussi ajouter des tests sur un flag dans ParsingHyperLong(), AnalyzingMegaComplexe(), CodageMoyenLong et PackagingPasCourt() !!

Désolé je vois pas d'autre solution propre.

**billynirvana** · 12/10/2006, 14h03

Si une classe implements Closeable, est il possible d'envoyer un evénement de cloture?

**professeur shadoko** · 12/10/2006, 14h36

Envoyé par mlle lain

Je trouve abérrant que ce soit si dur de trouver une solution à ça ...

au contraire: voir la discussion sur la suppression des méthodes suspend, resume, stop de Thread.
l'idée fondamentale est qu'un Thread est responsable pour prendre la décision de s'interrompre et qu'une interruption "extérieure" est trop dangereuse.
donc: de l'extérieur on peut demander à un Thread de bien vouloir s'arréter ("s'il vous plait") et c'est au Thread cible de prendre la décision et donc de tester une condition.

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 ThreadObeissant extends Thread{
	private  boolean suspended = false ; // "volatile" pas nécessaire
	private  boolean stopped ;// initialisé à false par défaut
 
       public ThreadObeissant() { super() ;} 
/*
       public ThreadObeissant(Runnable rr) { // pas tres pratique dans ce cas tres particulier
          super(rr) ;
      }
*/
 
	//////////////////////////////////////////////////////////////////////////
	/// ces trois méthodes sont appelés par d'autres processus que le Thread courant!
	//////////////////////////////////////////////////////////////////////////
	public  synchronized void suspendRequest() {
			checkAccess() ; //methode speciale limitant l'acces au ThreadGroup
			suspended = true ;
	}
 
	public  synchronized void stopRequest() {
			checkAccess() ;
			stopped = true ;
			notify() ; // utile si suspended
	}
 
	public  synchronized void resumeRequest() {
			checkAccess() ;
			suspended =false ;
			notify() ;
		}
	//////////////////////////////////////////////////////////////////////////
 
	/** permet de tester si le thread peut continuer
                * l'appel est bloquant si le Thread est suspendu
                *<P> si répond "false" on doit impérativement sortir du run
                * <P> IMPORTANT : cette méthode ne peut être appelée que du processus courant
                * décrit par le "ThreadObeissant" (contrairement aux méthodes ***request).
                */
	protected synchronized boolean going() {
		if( this != currentThread()) {// ceinture et bretelles
			throw new SecurityException("external thread cannot call going()") ;
		}
		while (suspended && !stopped) {
				try {
					wait() ;
				} catch (InterruptedException exc) {
					// stopped = true ; à décider
				}
			}
		return !stopped ;
		// return (!stopped) && (!isInterrupted()) ;
	}
 
 
}

**adiGuba** · 12/10/2006, 14h58

Salut,

Envoyé par professeur shadoko

au contraire: voir la discussion sur la suppression des méthodes suspend, resume, stop de Thread.
l'idée fondamentale est qu'un Thread est responsable pour prendre la décision de s'interrompre et qu'une interruption "extérieure" est trop dangereuse.

Hum ! Je n'aurais pas réussi à expliquer cela aussi clairement... (je risque de te piquer cette explication dans le futur

).

Pour en revenir à la méthode stop(), elle est dangereuse car elle peut laisser l'application dans un état incohérent (instance mal initialisé ou dans un état incorrect), et cela pourrait avoir des répercussions sur les autres threads de ton applications.

Le kill -9 est nettement moins dangereux car il tue toutes l'applications... il n'y a pas de risque de se retrouver dans un état incohérent...

Quel type de traitements tu effectues dans ton thread ? Cela pourrait nous aider à trouver une solution

a++

**mlle lain** · 12/10/2006, 15h30

Ben comme je l'ai dit précédemment (avant une certaine discussion sur le mérite comparée des méthodes de sorties d'une boucle while

) Je ne mets dans mon run qu'un appel à une fonction.

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
public void run() {
            try {                    
                File file = getCurrentFile();
                TestParser testParser = new TestParser();             
                    if (file.canRead()){                        
                        try {
                            testParser.process(file);
                            stopBar();
                            displayInfo("ICAr generate with sucess");        
                        } catch (cdi.amparser.HandlerException he) {
                            System.out.println(he.getMessage());
                            he.printStackTrace();
                            stopBar();
                            displayInfo("Compilation Error");    
                        }
                        catch (Exception e) {
                        System.out.println(e.getMessage());
                        stopBar();
                        displayInfo("Compilation Error");  
                        
                    }
                }
              } catch (NullPointerException npe) {
                    stopBar();               
              }                                    
        }

Alors même si je comprends la principe, je vois pas quand le thread se rencadre sur l'état de la variable ..

**adiGuba** · 12/10/2006, 15h40

Envoyé par mlle lain

Ben comme je l'ai dit précédemment (avant une certaine discussion sur le mérite comparée des méthodes de sorties d'une boucle while

) Je ne mets dans mon run qu'un appel à une fonction.

Oui j'ai bien lu ceci !

que fait cette fonction ???

a++

**mlle lain** · 12/10/2006, 15h57

Du parsing de fichier et de la génération de code. Y a 4 ou 5 appels à d'autres méthodes.
Mais je ne suis pas censée toucher à cette classe

**adiGuba** · 12/10/2006, 16h02

Envoyé par mlle lain

Du parsing de fichier et de la génération de code.
Mais je ne suis pas censée toucher à cette classe

Génération de code dans des fichiers ?

Il faudrait savoir si la gestion des IO est interruptible, comme par exemple en utilisant les FileChannel...

En effet ces derniers permettent de remonter une exception lorsque le thread est interrupted...

Maintenant si tu ne peux pas modifier ce code alors il n'y a pas vraiment de solution... a moins d'appeller Thread.stop() avec tout les risques que cela comporte...

a++