[Thread] Synchronisation de thread

Version imprimable

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:

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:

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 8O
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.

@++

21/06/2006, 12h54
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 :aie:

bye bye

Fred

Hello

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

Code:

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:

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 !

@++

21/06/2006, 13h10
in

euh c'est pas plutot un wait dans ton main et un notify à la fin de ta méthode ?
21/06/2006, 13h14
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) :aie:

@++

Salut,

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

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
    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++

21/06/2006, 13h15
nighthammer
Juste après ton :
Code:

1 2 t.start()
Il faut que tu rajoute :
Code:

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.

Ben, c'est pas mieux ! :

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
 
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().

@++

21/06/2006, 13h18
GLDavid

Cool !!!

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

@++
21/06/2006, 13h21
nighthammer

La solution du join ne serait pas plus simple, parce que là j'ai un l'impression que vous réinventez la roue. :D
21/06/2006, 14h15
adiGuba

Citation:

Envoyé par nighthammer

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

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++
21/06/2006, 14h48
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.

@++