Bonjour à tous,

Me voilà confronté à un problème épineux où je n'ai toujours pas trouvé de réponse. Je suis en train de développer le jeu des Inventeurs en client-serveur avec 2 IA jouant automatiquement entre elles, lors du lancement du client-serveur je me retrouve confronté à l'erreur suivante lorsque j'instancie les flux ObjectInputStream et ObjectoutputStream dans le traitementServeur et le traitementClient:

Joueur : 1 se connecte à l'adresse/127.0.0.1

Joueur : 2 se connecte à l'adresse/127.0.0.1

java.net.SocketException: Relais brisé (pipe)
at java.net.SocketOutputStream.socketWrite0(Native Method)
at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:109)
at java.net.SocketOutputStream.write(SocketOutputStream.java:153)
at java.io.ObjectOutputStream$BlockDataOutputStream.drain(ObjectOutputStream.java:1877)
at java.io.ObjectOutputStream$BlockDataOutputStream.setBlockDataMode(ObjectOutputStream.java:1786)
at java.io.ObjectOutputStream.<init>(ObjectOutputStream.java:247)
at Serveur.traitementServeur.run(traitementServeur.java:47)
at java.lang.Thread.run(Thread.java:745)
java.io.EOFException
at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2353)
at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:2822)
at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:804)
at java.io.ObjectInputStream.<init>(ObjectInputStream.java:301)
at Client.traitementClient.run(traitementClient.java:39)
at java.lang.Thread.run(Thread.java:745)
java.io.EOFException
at java.io.ObjectInputStream$PeekInputStream.readFully(ObjectInputStream.java:2353)
at java.io.ObjectInputStream$BlockDataInputStream.readShort(ObjectInputStream.java:2822)
at java.io.ObjectInputStream.readStreamHeader(ObjectInputStream.java:804)
at java.io.ObjectInputStream.<init>(ObjectInputStream.java:301)
at Client.traitementClient.run(traitementClient.java:39)
at java.lang.Thread.run(Thread.java:745)

Petites explications sur mon code je lance donc un serveur, après quoi je fais appel à la méthode openService pour ouvrir le service une fois cela fait j'instancie de nouveaux clients. Dans la méthode traitement connexion le thread serveur s'occupant des connexion va accepter les connexion clientes puis lancer le thread serveur s'occupant du lancement et du déroulement de la partie puis le constructeur du traitement serveur va instancier les thread clients et les lancer avec en paramètre la socket client associées récupérée par la méthode .accept(). Une fois les deux threads clients lancée le run du traitementServeur se lance et la partie commence.

classe Serveur:
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
public class Serveur{
	private final int    port       = 1028;
	private final String host       = "127.0.0.01";
 
	private Thread       serverConnexionThread;
 
	private ServerSocket serverSock;
	private Socket []    clientSocket;
 
	public Serveur(){
		try{
			this.serverSock = new ServerSocket(this.port, 10, InetAddress.getByName(this.host));
		} catch(UnknownHostException e) {
			e.printStackTrace();
		} catch(IOException e){
			e.printStackTrace();
		}
	}
 
	public void openService() throws IOException, Exception{
		this.serverConnexionThread = new Thread(new TraitementConnexionServeur(serverSock), "ThreadServerConnexion");
		this.serverConnexionThread.start();
	}
 
	public ServerSocket getSocket(){
		return this.serverSock;
	}
 
	public boolean getStateThread(){
		return this.serverConnexionThread.isAlive();
	}
}


classe TraitementConnexion qui gère le thread s'occupant des connexion clientes:

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
public class TraitementConnexionServeur implements Runnable{
	private ServerSocket socketServer;
	private Socket []    clientSocket;
	private Thread       serverJeuThread;
 
	public TraitementConnexionServeur(ServerSocket socketServ){
		this.socketServer = socketServ;
		this.clientSocket = new Socket [2];
	}
 
	@Override
	public void run() {
		try {
			int i           = 0;
			int nbConnexion = 0;
			while(nbConnexion < this.clientSocket.length){
				this.clientSocket[i++] = socketServer.accept();
				nbConnexion++;
				System.out.println("Joueur : " + i + " se connecte à l'adresse" + this.clientSocket[i -1].getInetAddress());
			}
				this.serverJeuThread = new Thread(new traitementServeur(this.clientSocket, this.socketServer), "threadServerJeu");
				this.serverJeuThread.start();
		} catch (Exception ex) {
			Logger.getLogger(TraitementConnexionServeur.class.getName()).log(Level.SEVERE, null, ex);
		}
 
	}
 
}


classe TraitementServeur s'occupant de la mise en place de la partie une fois les connexion clientes effectuées:

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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
public class traitementServeur implements Runnable {
	// Variable du constructeur
	private ServerSocket socketServer;
	private Socket []    socketJoueurs;
	private Thread []    threadJoueurs;
	private MoteurJeu    moteur;
 
	private ObjectOutputStream [] out;
	private ObjectInputStream  [] in;
 
	public traitementServeur(Socket [] clients, ServerSocket currentSocket) throws IOException, Exception{
		this.socketServer = currentSocket;
		this.moteur = new MoteurJeu();
		this.threadJoueurs = new Thread [clients.length];
		this.socketJoueurs = new Socket [clients.length];
		this.out = new ObjectOutputStream [clients.length];
		this.in = new ObjectInputStream [clients.length];
		for(int i = 0; i < clients.length; i++){
			this.socketJoueurs[i] = clients[i];
			this.threadJoueurs[i] = new Thread(new traitementClient(this.socketServer,this.socketJoueurs[i], this.moteur), "Joueur "+(i + 1));
			this.threadJoueurs[i].start();
		}
	}
 
	@Override
	public synchronized void run() {
		boolean tourJ1 = true;
 
		try{ 
			for(int i = 0; i < this.socketJoueurs.length; i++){
				this.out[i] = new ObjectOutputStream(socketJoueurs[i].getOutputStream());
				out[i].flush();
			}
			for(int i = 0; i < this.socketJoueurs.length; i++){
				this.in [i] = new ObjectInputStream (socketJoueurs[i].getInputStream());
			} 
 
			while(!moteur.finPartie()){
				while(!moteur.ageTermine()){
					if(tourJ1 == true){
						this.out[0].writeObject(this.moteur.getJeuCourant());
						this.out[0].flush();
						Object finTour = in[0].readObject();
						this.moteur.majJeu((ArrayList<Invention>) finTour, 1);
						tourJ1 = false;
					} else{
						this.out[1].writeObject(this.moteur.getJeuCourant());
						this.out[1].flush();
						Object finTour = in[1].readObject();
						this.moteur.majJeu((ArrayList<Invention>) finTour, 2);
						tourJ1 = true;
					}
				}
				System.out.println("l'age "+this.moteur.getAgeInvention()+" est terminé");
				this.moteur.changementAge();
			}
			// On envoie flux de caractère avec le nom du vainqueur au client
			OutputStream os;
			OutputStreamWriter ow;
			BufferedWriter wr;
			for (int i = 0; i < socketJoueurs.length; i++){
				try {
					os = socketJoueurs[i].getOutputStream();
					ow = new OutputStreamWriter(os);
					wr = new BufferedWriter(ow);
					wr.write(this.moteur.Vainqueur()+"\n");
					wr.flush();
					wr.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			this.in[0].close();
			this.in[1].close();
			this.out[0].close();
			this.out[1].close();
 
		} catch (Exception e){
			e.printStackTrace();
		}
	}
}


classe client:

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
public class Client {
	private Socket socket;
	private String host = "localhost";
	private int    port = 1028;
 
	public Client(String host, int port){
        try {
			this.socket = new Socket(host, port);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public Client(){
		try {
         this.socket = new Socket(this.host, this.port);
      } catch (UnknownHostException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
	}
}


classe traitementClient qui gère le thread client lors de la partie:

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
public class traitementClient implements Runnable{
	private ServerSocket socketServer;
	private Socket       currentSocket;
	private IA           IAJoueur;
	private static int   nbClient = 0;
 
	public traitementClient(ServerSocket sockServ, Socket socket, MoteurJeu moteur){
		this.socketServer  = sockServ;
		this.currentSocket = socket;
		if(traitementClient.nbClient == 0)
			this.IAJoueur = moteur.chargementJoueur("Maxime");
		else
			this.IAJoueur = moteur.chargementJoueur("Guillaume");
 
		traitementClient.nbClient++;
	}
 
	@Override
	public synchronized void run() {
		try {
			ObjectOutputStream out = new ObjectOutputStream(this.currentSocket.getOutputStream());
			out.flush();
			ObjectInputStream  in  = new ObjectInputStream (this.currentSocket.getInputStream());
			InputStream os = this.currentSocket.getInputStream();
			InputStreamReader ow = new InputStreamReader(os);
			BufferedReader wr = new BufferedReader(ow);
 
 
			while(wr.readLine() == null && wr.readLine() != "EXIT"){
				if(in.readObject() != null){
					ArrayList<Invention> jeu = ((ArrayList<Invention>) in.readObject());
					ArrayList jeuUpdate = this.IAJoueur.IaJoue(jeu);
					out.writeObject(jeuUpdate);
					out.flush();
				}
			}
			in.close();
			out.close();
			wr.close();
			this.currentSocket.close();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
 
}


Merci d'avance pour vos retours, en espérant que vous pourrez m'aider.