Discussion :

[GLDavid]

Bonjour

Voici mon problème. Dans une fonction, je crée un thread. Pour le moment, ce thread ne s'occupe que d'afficher un message :

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
 
private void launchBlast() throws IOException{
		System.out.println("Blasting...");
		Thread t = new Thread(){
			public void run(){
				String cmd = "ssh gldavid@cluster blastall -p blastn -d "+db+" -i "+inputfile+" -m 7 -o "+outputfile;
				System.out.println(""+cmd);
				//Runtime.getRuntime().exec(cmd);
			}
		};
		t.start();
	}
 
	/**
         * @param args
         */
	public static void main(String[] args) throws IOException {
		JBlast jBlast = new JBlast();
		jBlast.verifyArgs(args);
		jBlast.launchBlast();
		System.out.println("Finished the blast");
	}

Or, avec ce code, je remarque l'affichage suivant à l'exécution :

Code :

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

1
2
3
4
 
Blasting...
Finished the blast
ssh gldavid@cluster blastall -p blastn -d /bioxpr/cluster/databases/blast/refseq/Homo_sapiens/refseq_Homo_sapiens_rna -i /home/gldavid/seq.txt -m 7 -o /home/gldavid/results.xml

Donc, le thread est exécuté après ma fonction
J'eus plutôt souhaité avoir le message de mon thread avant la fin de ma fonction.

Comment résoudre donc ce problème ?

Merci d'avance de votre aide.

@++

[mavina]

Salut,

Justement l'interet du thread est de pouvoir effectuer 2 taches en même temps, donc ta fonction lance ton thread et se termine, le thread lui s'execute en même temps que ton System.out.println ... Il est donc plutot logique que tu aie ce résultat.
Pour ce qui est de la synchronisation, je ne vois pas trop de solution à ton probleme, je me trompe peut-être mais il me semble que tu cherches à faire du mono-thread en multi-thread

bye bye

Fred

[GLDavid]

Hello

Merci de ta réponse Mavina.
J'ai tenté de faire attendre mon processus principal :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
private void launchBlast() throws IOException, InterruptedException {
		System.out.println("Blasting...");
		Thread t = new Thread(){
			public void run(){
				String cmd = "ssh gldavid@cluster blastall -p blastn -d "+db+" -i "+inputfile+" -m 7 -o "+outputfile;
				System.out.println(""+cmd);
				//Runtime.getRuntime().exec(cmd);
			}
		};
		t.start();
		while(t.isAlive())
			this.wait();
	}

Mais bon, je me mange cette erreur :

Code :

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

1
2
3
4
5
6
7
8
 
Blasting...
Exception in thread "main" java.lang.IllegalMonitorStateException
	at java.lang.Object.wait(Native Method)
	at java.lang.Object.wait(Object.java:474)
	at com.bioxpr.JBlast.JBlast.launchBlast(JBlast.java:69)
	at com.bioxpr.JBlast.JBlast.main(JBlast.java:78)
ssh gldavid@cluster blastall -p blastn -d /bioxpr/cluster/databases/blast/refseq/Homo_sapiens/refseq_Homo_sapiens_rna -i /home/gldavid/seq.txt -m 7 -o /home/gldavid/results.xml

pas cool !

@++

[in]

euh c'est pas plutot un wait dans ton main et un notify à la fin de ta méthode ?

[GLDavid]

Sans doute oui ! Les thread n'ont jamais été mon fort (en témoigne mes notes pitoyables sur ce sujet pour la simulation SCJP)

@++

[adiGuba]

Salut,


wait() permet de faire le la synchronisation et doit obligatoirement être utilisé dans un bloc synchronized :

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
    private void launchBlast() throws IOException {        
        System.out.println("Blasting...");
        Thread t = new Thread(){
            public void run(){
                String cmd = "ssh gldavid@cluster blastall -p blastn -d db -i inputfile -m 7 -o outputfile";
                System.out.println(""+cmd);
                //Runtime.getRuntime().exec(cmd);
                
                // On notifie l'élément parent :
                synchronized(JBlast.this) {
                    JBlast.this.notify();
                }
            }
        };
        t.start();
        
        // On se met en attente jusqu'à ce qu'on soit notifié
        synchronized(this) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // Interrupted
                e.printStackTrace();
            }
        }
    }

il faudrai toutefois utiliser le wait() avec un timeout et vérifier l'état réel du thread pour éviter les interblocages...

Mais du coups je suis plutôt d'accord avec mavina : pourquoi faire un thread si c'est pour attendre qu'il se termine pour continer ???

a++

[nighthammer]

Juste après ton :

Code :

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

1
2
 
t.start()

Il faut que tu rajoute :

Code :

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

1
2
 
t.join()

Ca va faire en sorte que ton programme courant va attendre que ton thread soit terminé pour continuer à s'exécuter.

[GLDavid]

Ben, c'est pas mieux ! :

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
 
private void launchBlast() throws IOException, InterruptedException {
		System.out.println("Blasting...");
		Thread t = new Thread(){
			public void run(){
				String cmd = "ssh gldavid@cluster blastall -p blastn -d "+db+" -i "+inputfile+" -m 7 -o "+outputfile;
				System.out.println(""+cmd);
				//Runtime.getRuntime().exec(cmd);
			}
		};
		t.start();
		//System.out.println(""+t.getPriority());
		while(t.isAlive())
			this.notify();
	}
 
	/**
         * @param args
         */
	public static void main(String[] args) throws IOException, InterruptedException {
		JBlast jBlast = new JBlast();
		jBlast.verifyArgs(args);
		jBlast.wait();
		jBlast.launchBlast();
		System.out.println("Finished the blast");
	}

Apparemment, il se plante toujours sur le wait().

@++

[GLDavid]

Cool !!!

Un grand merci à adiGuba
Merci à toi !!! Peut être vais-je un peu mieux comprendre les Threads avec ça

@++

[nighthammer]

La solution du join ne serait pas plus simple, parce que là j'ai un l'impression que vous réinventez la roue.

[adiGuba]

La solution du join ne serait pas plus simple, parce que là j'ai un l'impression que vous réinventez la roue.

Oui en effet la solution de join() est bien meilleure pour attendre la fin du thread. Le couple wait()/notify() permet par contre beaucoups plus de chose du coté de la synchronisation...

A noter également l'existence des Lock et de plusieurs autres fonctionnalitées dans le package java.util.concurrent de Java 5.0...

Mais dans les deux cas, exécuter un thread pour attendre qu'il soit fini est un peu inutile...

a++

[GLDavid]

Je me permet d'ajouter cette précision que j'aurais dû mentionner plus haut.
J'ai dû développer aux normes Java 1.4.2.

@++