Version imprimable
Bonjour,
j'ai développé un serveur concurent qui gere plusieurs clients en meme tps.
le probleme c'est que j'ai un une variable qui s'incremente à chaque requette d'un client (un client pouvant effectuer plusieurs requettes) pour tous les clients, a la fin j'ai besoin d'afficher cette variable a chaque client, lorsque tous les clients connectés auront fini leur requettes sachant que tous les clients ne finissent pas leurs requettes en meme temps.
Avez vous une idée de ce que je dois faire?
tu peux synchroniqer tes thread en mettant le modifier synchronized dans la signature de ta méthode pour synchroniser les méthodes que tu veux. Sinon pour ne synchroniser que certaines parties du code, jette un oeil à ReentrantLock (un truc comme ça), y a déjà des topics postés sur le sujet.
j'ai déjà essayé ca.
bon en gros voila mon pb:la variable dont je parlais est count:
public class Serv {
private final ServerSocket serverSocket;
private static int count=0;//nombre de requettes sur le serveur
//...
public Serv(int port) throws IOException{
//initialisation du serveur attaché au port choisi
serverSocket =new ServerSocket(port);
System.out.println("Serveur attache a :"+
serverSocket.getLocalSocketAddress()+"\n");
}
public void launch()throws IOException
{
while(true)
{
final Socket client=serverSocket.accept();
new Thread(new Runnable()
{
public void run()
{
serveClient(client);
}
}).start();
}
}
public static void serveClient(Socket client) {
String pseudo = "";
try {
//...code trop long
BufferedReader br=new BufferedReader(new InputStreamReader
(client.getInputStream(),"UTF8"));
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter
(client.getOutputStream(),"UTF8"));
bw.write("==>Bonjour choisir un pseudo: ");
bw.newLine();
bw.flush();
//...
// boucle: tant que le client effectue une requette
count++;
//fin de boucle
bw.write("le nombre de requettes sur le serveur est de:"
+count);//ici il faut attendre la fin des requettes de tous les clients
bw.newLine();
bw.flush();
//...
}catch (IOException e) {
e.printStackTrace();
}
finally{
try{
client.close();
}catch(IOException e){}
}
}
public static void main(String[] args) throws IOException {
Serv server;
//...code trop long
server=new Serv(Integer.parseInt(args[0]));
server.launch();
}
}
alors comment attendre que tous les clients connectés aient fini leurs requettes pour afficher la variable count à tous les clients.
en efet, utiliser une variable d'empêche de synchroniser son incrémentation. Il suffit tout simplement de créer une méthode increment() avec le mot clef synchronized et pour seul code count++
Simple et efficace.
merci, mais j'ai déjà essayé de synchroniser comme t'as dit et ca n'empeche pas l'affichage de la variable avant que tous les utilisateurs aient terminé leurs requettes.j'ai meme crée une fonction affche() avec le mot synchronized mais sans effet.
S'il y a autre solution ou autre proposition elle est la bienvenue
Tu peux simplement faire:Citation:
Envoyé par Razgriz
Code:synchronized(unVerrou) { count++; }
oui j'ai déjà essayé mais ca ne marche pas non plus dans mon contexte.
Franchement je sais pas quoi faire ave cette histoire là!!!:?
Je n'ai pas très bien compris ce que tu cherchais à faire...
En gros, supposons qu'il y a 5 clients qui se connectent, tu veux envoyer la valeur de la variable à quel moment?
ok je t'explique: supposant qu'il y a 5 clients connectés au serveur, chaque client est géré par un thread, chaque client fait ses requettes et un client peut terminer avant les autres, je veux attendre que tous les clients connectés aient fini leurs requettes pour envoyer la variable.voilà.;)
En même temps, si tes clients sont connectés pour attendre de recevoir la variable, il ne se déconnectent pas, et donc personne se déconnecte...Citation:
Envoyé par dimitri1233
oui t'as tout compris personne ne se deconnecte avant de recevoir la variable count.
Ne se déconnecte pas?Citation:
Envoyé par dimitri1233
Dans ce cas là, ils vont tous s'attendre les uns les autres...
Du groupe je suis sûrement celui qui a le plus faible niveau en Java mais il semblerait qu'ici le problème soit d'ordre logique. J'ai une idée, mais je ne pourrait pas donner la traduction en code Java de ce que je vais exprimer...
Pour résumer :
- La variable count est reçu à la déconnexion,
- Pour pouvoir se déconnecter, il faut recevoir la variable count.
Mon idée est la suivante :
Les clients font leurs tâches. Dès qu'ils ont fini, ils envoi une requête de déconnexion (mise en pause du thread peut-être ?)
Dès que tout le monde a émis cette requette (que tous les threads sont en pause ?), on leur balance la variable count et bye bye ! Il sont déconnecté à ce moment là.
J'espère avoir pu aider à mon petit niveau... :mrgreen:
bonne idée mais c'est pas si evident de la mettre en oeuvre ce que tu viens de dire:Citation:
Envoyé par Willy_XIII
mettre tous les threads en pause risque de coupper les requettes des clients sachant qu'un client peut finir ses requettes avant les autres et la les clients recevront une reponse fausse(pas la valeur exacte de la varible) tu vois un peu le truc?
Ce que je voulais dire, c'est que c'est le client qui met en pause son propre thread (avec une connerie genre "Envoyer une requête de déconnexion") qui implique donc que le client ne fera plus rien après. Une fois que tout le monde a mis en pause son thread, on balance la variable et on déconnecte réellement tout le monde.Citation:
mettre tous les threads en pause risque de coupper les requettes des clients sachant qu'un client peut finir ses requettes avant les autres
Et imagine qu'il y ait 5 utilisateurs connectés, 4 qui attendent d'êtres déconenctés et un dernier qui va bientôt finir. Un nouvel utilisateur se connecte... Les 5 autres vont devoir encore attendre,c'est le cauchemard. Est-tu certain que envoyer la variable incrémentée dès qu'il n'y a plus d'utilisateurs en ligne soit la bonne approche?
D'un point de vue logique, en quoi consiste cette variable et à quoi sert-elle?