Salut    
j'aurai besoin de votre aide pour un ptit programme que je dois écrire. il me faut créer un serveur et 2 clients, tous sur un poste différent, et des processus doivent s'executer sur chaque poste. chaque processus est indépendant d'un autre. il me faut faire communiquer chaque processus avec le serveur et réciproquement et je n'arrive pas à trouver comment faire sans créer un nouveau socket pour chaque "canal" de communication. en gros, je voudrais, par exemple, utiliser le socket créé entre le serveur et client1 pour faire tous les processus sur client1 communiquer avec le serveur. je vois comment faire un créant un nouveau socket pour chaque processus mais je voudrais savoir s'il est possible de le faire avec un seul socket.
je pensais utiliser des blockingQueue que je passe à client1, par exemple, si j'ai 1 processus sur client1, depuis le serveur j'envoie 1 blockingQueue (qui est utilisé comme input depuis le serveur) dans le outputStream, client1 le récupère et l'utilise comme output. sauf que quand je lis depuis le blockingQueue depuis le serveur, il ne lit rien
voici le code que j'ai utilisé comme test :  
 
la classe Serveur
 
package testbq;
import java.net.Socket;
import java.net.ServerSocket;
import java.io.*;
import java.lang.*;
import java.util.concurrent.*;
 
public class Serveur {
    ServerSocket ss;
    Socket s;
    int n;
    private ObjectOutputStream oout;
    BlockingQueue bq;
    BQObjectInput bqin;
    String x;
     
    public Serveur() {
        while(true) {
            try {
                ss = new ServerSocket(12345);
                try {
                    s = ss.accept();
                    try {
                        BufferedReader is = new BufferedReader (new InputStreamReader(s.getInputStream()));
                        PrintWriter os = new PrintWriter(s.getOutputStream(), true);
                        oout = new ObjectOutputStream(s.getOutputStream());
                        bq = new ArrayBlockingQueue(1);
                        bqin = new BQObjectInput(bq);
                        os.println("Connexion établie" );
                        oout.writeObject(bq);
                        System.out.println("bq envoye" );
                        x = (String)bqin.readObject();
                        System.out.println(x);
                    }
                    finally { s.close(); }
                }
                finally { ss.close(); }
            }
            catch (IOException e) { System.out.println("error!" ); }
        }
    }
     
    public static void main (String args[]) {
        Serveur s = new Serveur();
    }
     
}
 

 
la classe Client
 
package testbq;
import java.net.*;
import java.io.*;
import java.util.*;
import java.util.concurrent.*;
import java.lang.*;
 
public class Client {
    Socket s;
    int n;
    private ObjectInputStream oin;
    BQObjectOutput bqout;
    String x;
    Message m1, m2, m3;
     
    public Client() {
        try {
            s = new Socket("192.168.0.3", 12345);
            try {
                BufferedReader is = new BufferedReader (new InputStreamReader(s.getInputStream()));
                PrintWriter os = new PrintWriter(s.getOutputStream(), true);
                oin = new ObjectInputStream(s.getInputStream());
                 
                System.out.println(is.readLine());
                 
                try{bqout = new BQObjectOutput((BlockingQueue)oin.readObject());}catch (Exception e){System.out.println("getting bq failed" );}
                System.out.println("bq recu" );
                bqout.writeObject("coucou" );
                System.out.println("msg envoye" );
                 
            }
            finally { s.close(); }
        }
        catch (IOException e) { System.out.println("error client!" ); }
    }
     
    public static void main (String args[]) {
        Client c = new Client();
    }    
}
 
 

 
la classe BQObjectInput (que j'utilise comme "adaptateur" pour le blockingQueue)

package testbq;
 
 
import java.io.*;
import java.util.concurrent.*;
 
class BQInputStream extends InputStream {
 private BlockingQueue<Object> bq;
 
 /** Creates a new instance of BQInputStream */
 public BQInputStream(BlockingQueue<Object> bq) {
  this.bq = bq;
 }
 
 public int read() {
  try {
   Integer value = (Integer) bq.take();
   return value;
  } catch (InterruptedException e) {
   return 0;
  }
 }
}
 
public class BQObjectInput extends DataInputStream implements ObjectInput {
 BlockingQueue<Object> bq;
 
 /** Creates a new instance of ObjectInput */
 public BQObjectInput(BlockingQueue<Object> bq) {
  super(new BQInputStream(bq));
  this.bq = bq;
 }
 
 public Object readObject() {
  try {
   return bq.take();
  } catch (InterruptedException e) {
   return null;
  }
 }
}
 

la classe BQObject Output (...)
 
package testbq;
 
import java.io.*;
import java.util.concurrent.*;
 
class BQOutputStream extends OutputStream {
 private BlockingQueue<Object> bq;
 
 /** Creates a new instance of BQOutputStream */
 public BQOutputStream(BlockingQueue<Object> bq) {
  this.bq = bq;
 }
 
 public void write(int value) {
  try {
   bq.put(value);
  } catch (Exception e) {
  }
 }
}
 
public class BQObjectOutput extends DataOutputStream implements ObjectOutput {
 BlockingQueue<Object> bq;
 
 /** Creates a new instance of ObjectOutput */
 public BQObjectOutput(BlockingQueue<Object> bq) {
  super(new BQOutputStream(bq));
  this.bq = bq;
 }
 
 public void writeObject(Object v) {
  try {
   bq.put(v);
  } catch (Exception e) {
  }
 }
}

 
je ne m'y connais pas des masses en programmation réseau et je serai vraiment reconnaissant si vous pouviez m'aider plz

y a personne qui s'y connait dans le coin?