Problème avec des threads

Version imprimable

06/02/2007, 16h32
rajuto

Problème avec des threads

Voila je crée plusieurs threads, dans le run je fais un sleep(une_valeur), puis j'appelle une méthode print() qui affiche 2-3 lignes d'informations, le problème c'est que dans 2 de mes processus je dois avoir la même valeur du paramètre du sleep, après le lancement des threads j'ai l'affichage de ces 2 processus qui est entremélé pourtant ma méthode print() est bien définie synchronized .

Merci de votre aide :D
06/02/2007, 16h35
mrkzed

Tu pourrais nous montrer ton code, et ce que tu obtiens a l'execution ?
07/02/2007, 14h16
Didier 69

c'est bien l'ensemble des print qui sont synchronisés ?
07/02/2007, 14h54
maxf1

Pourquoi faire un sleep de tes threads. Tu as autant mettre le sleep dans ton print. Si la methode est synchronized si un thread tombe dans le sleep les autres attendront aussi.

Une solution toute bete : ton print est bien synchro mais ta methode est traité tellement rapidement que eclipse n'arrive pas à suivre et t'affiche ton print entremelé. D'ou un sleep dans ton print comme ca tu es sur que le print à le temps de s'afficher avec qu'un autre puisse aller dedans et faire un autre print.
07/02/2007, 20h33
Sanguko

Verifie eventuellement si ta methode print() est static, ou si tu utilises le meme objet.
08/02/2007, 14h11
rajuto

la solution du sleep dans le print ne change rien, je posterai mon code quand je rentrerai des cours ce soir, en tout cas merci ... :D
08/02/2007, 15h59
maxf1

Si le sleep dans le print ne marche pas alors tu n'as pas du bien synchroniser ta méthode. ;)
On attend ton code car sans c'est pas possible de t'aiguiller plus.

Voila j'ai 2 Mains :

Un serveur :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.net.*;
import java.io.*;
 
public class MainServer {
	public static void main(String args[]){
		try{
			ServerSocket ss=new ServerSocket(12345);
			System.out.println("en attente...");
			ss.accept();
			System.out.println("client connecte...\n");
			new MapProcessus(10).start();
		}catch(IOException e){}
	}
}

un client :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import java.net.*;
import java.io.*;
 
public class MainClient {
	public static void main(String args[]){
		try{
			new Socket("localhost",12345);
			System.out.println("connecte\n");
			new MapProcessus(10).start();
		}catch(IOException e){
 
		}
	}
}

une map de processus:

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
import java.util.TreeMap;
import java.util.Iterator;
 
public class MapProcessus extends TreeMap<Integer,Processus>{
	private static final long serialVersionUID=1L;
 
	public MapProcessus(int N){
		super();
 
		for(int i=1;i<=N;i++){
			int debut=(int)(Math.random()*10);
			if(debut<=5)
				put(i,new ProcessusType1(i,i*100,debut));
			else
				put(i,new ProcessusType2(i));
		}
	}
 
	public void start(){
		Iterator it=keySet().iterator();
		while(it.hasNext()){
			Integer i=(Integer)it.next();
			Processus p=get(i);
			p.start();
		}
	}
}

classe processus :

Code:

1
2
3
4
5
6
7
8
9
abstract public class Processus extends Thread{
	protected int id;
 
	synchronized public void print(){
		System.out.println("Je suis le Processus "+id);
	}
 
	abstract public void run();
}

processus de type 1 :

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
public class ProcessusType1 extends Processus{
	private double val;
	private int debut;
 
	public ProcessusType1(int id,double val,int debut){
		this.id=id;
		this.val=val;
		this.debut=debut;
	}
 
	synchronized public void print(){
		super.print();
		System.out.println(id+" : Je suis du type 1");
		System.out.println(id+" : val --> "+val);
		System.out.println(id+" : debut --> "+debut);
		System.out.println("");
	}
 
	public void run(){
		try{
			sleep(debut*1000);
			print();
		}catch(InterruptedException e){
 
		}
	}
}

processus de type 2 :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ProcessusType2 extends Processus{
	public ProcessusType2(int id){
		this.id=id;
	}
 
	synchronized public void print(){
		super.print();
		System.out.println("Je suis du type 2");
		System.out.println("");
	}
 
	public void run(){
		print();
	}
}

11/02/2007, 20h41
Sanguko

Une methode déclarée synchronized verrouille l'acces à la methode si tu l'appelles avec la meme instance.

Par exemple, si tu as deux threads 1 et 2, qui utilise le meme objet créé a partir de la classe ProcessusType1, la methode print appelée dans un thread sera bloquante pour l'autre.

Tu n'es pas dans ce cas : chaque thread a sa propre instance.

Une solution possible consisterait à rendre ta methode static (avec eventuellement en parametre une instance). Le verrou ne se fait plus sur l'instance mais sur la classe, qui, elle, est partagée entre les differents threads.

Je t'invite également à lire (ou sans doute relire) de la documentation sur ce sujet. Tu auras une vision bien plus claire de ce qui se passe. Je suis malheureusement trop nouveau sur ce site pour t'indiquer un lien, mais je j'imagine qu'il doit y avoir ce qu'il faut.