Performances d'un serveur.

**edenroad** · 26/04/2012, 15h34

Bonjour,
Je suis actuellement en train de réaliser une application client/serveur pour un petit jeu en ligne.
J'ai quelques soucis de performances avec mon serveur. Voici son schéma :
J'ai un Thread qui s'occupe d'accueillir le client jusqu'à sa connexion (un par client) et qui envoie ensuite le client dans un container :
le container est un triplet de Threads.
Chaque container contient au maximum 10 clients dans une ArrayList.
Le container distribue chaque client parmis ces trois Threads :
Un bufferedReader pour le Thread qui recevra les packets et un PrintWriter pour le Thread qui enverra les paquets.
Le dernier Thread est celui qui traite les paquets. Ces trois Thread sont reliés pas des tubes interThread : PipedWriter et PipedReader.
Tout marche parfaitement seulement, lors de la connexion d'un client, le processeur s'excite et affiche 100% d'utilisation, donc en gros il est au maximum de ses capacités. J'ai bien vérifié, aucun Thread de trop n'est lancé, et à chaque déconnexion/vidage d'un container, les threads sont tués.

Pour la réception des paquets : une boucle for qui parcourt l'ArrayList de BufferedReader : Si il y a quelque chose a lire dans le br on le lit, sinon on passe au suivant. tout ça dans une boucle while qui se stoppe uniquement si le container est vide.

Est ce ma méthode qui ne fonctionne pas ? D'ou peut bien venir ce problème ? Je n'ai pas un PC surpuissant mais je n'ai jamais réussi à atteindre ces 100% d'utilisation...

**adiGuba** · 26/04/2012, 16h54

Salut,

100% d'utilisation CPU et une boucle infini... J'ai bien peur que ta boucle tourne un peu trop !

Quels sont les informations qui doivent être échangé ? On pourrait voir un peu de code ?

a++

**edenroad** · 26/04/2012, 17h52

Les informations échangées ? l'id du compte propriétaire du message, une chaine de caractères contenant le paquet à transmettre.
Voici le code : du Receiver.

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
package network;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.util.ArrayList;
 
import common.Container;
import manager.Writer;
 
public class Receiver extends Thread {
 
	private ArrayList<BufferedReader> in = new ArrayList<BufferedReader>(); // Liste de tous les br (l'id dans l'arraylist est la même pour chaque partie du container)
	private Writer out; // Le writer est un objet que j'ai créé (contrairement au Writer de java.io) qui contient un PipedWriter avec un systeme pour "normaliser" les paquets.
	private String packet;
	private Container container;
 
	public Receiver(Writer _out, Container _container) { // Constructeur
		this.out = _out;
		container = _container;
	}
 
	public void run() {
		while (true) {
			for (BufferedReader br : in) {  // Parcours de la liste de in
				try {
					if (br.ready()) { // Si il y a quelque chose à lire
						packet = br.readLine(); // on le lit
						System.out.println("Receiver : J'ai reçu le paquet " + packet); // Mouchard
						out.send(packet, in.indexOf(br)); // On l'envoi dans le tube au Handler (traitement du packet)
					}
				} catch (IOException e) {
					int id = in.indexOf(br);
					System.out.println("Probleme avec le compte d'id : " + id + ", kick du compte");
					container.kickID(id);
				}
				try {
					Thread.sleep(10); // J'ai essayé de faire dormir le Thread après chaque br testé, mais ça ne change rien.
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
 
	}
 
	public void add(BufferedReader _in) {
		in.add(_in);		
	}
 
	public void remove(int id) {
		in.remove(id);
	}
 
}

**adiGuba** · 26/04/2012, 18h35

Normal : tu utilises une boucle active !!!

Ton code consomme plus de CPU quand il ne fait rien, puisqu'il passe son temps à tourner en rond dans une boucle vide...

Essayes d'augmenter le temps du sleep(), et de le déplacer dans le while()...

Mais je pense que tu devrais te tourner vers NIO.2 qui propose des selecteurs pour cela.

Attention également au fait que ton code n'est pas du tout synchronisé

a++

**edenroad** · 26/04/2012, 18h40

Comment ça pas synchronisé ? (encore des choses à apprendre

)
Je vais faire un tour pour savoir ce qu'est NIO.2
Le déplacer ? Pour le mettre où ? j'ai déjà essayé en dehors du for mais sans succès, je vais essayer d'augmenter le temps d'attente.

**edenroad** · 26/04/2012, 18h53

Le truc, c'est que je ne vois pas quelle méthode synchronisée dans ma classe Receiver.

**JoeChip** · 27/04/2012, 11h18

Déjà,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

while (true)

, c'est mauvais : tu ne veux pas que ta boucle tourne jusqu'à la fin des temps, il y a donc une condition de sortie, donc cela ne correspond pas à ce que tu veux faire.

Ensuite, comment appelles-tu ce thread "Receiver" ? Par "run" ou par "start" ?

**edenroad** · 27/04/2012, 12h05

Le while (true) est temporaire, je compte mettre un timer qui "détruit" les container vides toute les x minutes.
J'appelle mon Receiver par receiver.start() sinon quel interet de l'extends en Thread ?

**edenroad** · 27/04/2012, 12h10

En ajoutant un Thread.sleep(100); à chaque boucle (recevier, handler, sender) j'obtiens un processeur moins excité, mais je ne pense pas que ce soit la solution...

**JoeChip** · 27/04/2012, 12h55

Pour "run/start" je pose la question parce qu'on ne sait jamais, quoiqu'en relisant mieux j'aurais peut-être pu le comprendre tout seul.

Sinon pourquoi 100 dans les sleeps ? comment as-tu calculé ça ?

**edenroad** · 27/04/2012, 13h33

J'ai testé avec plusieurs valeurs, le 100 est un peu hasardeux enfait...
J'ai changé le while (true) par un while (boolean) et ce booléen passe à faux lorsque le container est vide. (timer de 10 minutes).
Je ne sais pas par quoi remplacer les 100 ms... C'est une solution de secours mais je pense que c'est la moins efficace..;

**JoeChip** · 27/04/2012, 15h57

Pas forcément... Il faut calculer un peu le temps que prennent les choses, et voir... en revanche, mettre plusieurs sleep je ne pense pas que ce soit une bonne idée...

**edenroad** · 27/04/2012, 16h20

A terme ce sera 10 joueurs max par container.
On pourrait faire une formule pour calculer le temps d'attente en fonction du nombre de clients dans le container.
Pour les sleep il y en a un par Thread. ça devrait suffire je pense.
je pensais 200ms / x avec x le nombre de client.
Ou sinon on nombre constant, mais lequel...

**JoeChip** · 27/04/2012, 19h31

Tu peux peut-être faire un petit interface d'options pour régler facilement et pouvoir tester sans devoir changer le code ; c'est probablement ce que je ferais.

**edenroad** · 27/04/2012, 20h55

Oui pas bête ! et je regarde lequel est le plus efficace.

**edenroad** · 30/04/2012, 11h16

Il n'y a pas un système de notification avec les socket autre que Socket.ready() ?
Normalement je crois que le caractère signifiant qu'il n'y a rien à lire est -1 ?

Performances d'un serveur.

Java

Discussions similaires

Partager

Partager