Discussion :

[NutellaPiou]

Bonjour à tous,

J'ai un petit soucis au niveau performance de mon application. Mon serveur lance toute une série de thread (qui font des checks sur des db). Ensuite une fois les thread lancés, il attend les connexions des clients.

Code Serveur :

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
 
//lancement des threads
 
try
{
    ServerSocket serveur = new ServerSocket(8254);
    int waitTime = Integer.parseInt(file.readFromFile("main", "waitTime"));
    while(true)
    {
        Socket connexion = serveur.accept();
        new ServerThreadConnection(connexion,statusDB,waitTime).start);     
    }
}
catch (IOException ex)
{
    System.out.println("IOException " + ex);
}

Mes threads mettent à jour tout les x secondes un objet Status qui contient des string avec les infos des db.

J'essaie d'afficher à mon/mes clients tout les x temps ces strings.
J'ai fait comme ceci dans ma classe ServerThreadConnection

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
public class ServerThreadConnection extends Thread
{
    private Socket connection;
    private ArrayList<Status> statusDB;
    private int waitTime;
 
    public ServerThreadConnection(Socket connection, ArrayList<Status> statusDB, int waitTime)
    {
        this.connection = connection;
        this.statusDB = statusDB;
        this.waitTime = waitTime;
    }
    public void run()
    {
        BufferedReader entree = null;
        try
        {
            entree = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            PrintWriter sortie = new PrintWriter(connection.getOutputStream(), true);
 
            sortie.println("Bienvenue");
            sortie.println("Tapez 1 pour monitorer");
            sortie.println("Tapez 0 quitter");
            int choix = Integer.parseInt(entree.readLine());
            if(choix == 1)
            {
               /* try {
                            ServerThreadConnection.sleep(waitTime);
                        } catch (InterruptedException ex) {
                            Logger.getLogger(ServerThreadConnection.class.getName()).log(Level.SEVERE, null, ex);
                        }*/
                long time = System.currentTimeMillis();
                while(true)
                {
                    if((System.currentTimeMillis() < ((100 + time + waitTime))) && (System.currentTimeMillis() > ((-100 + time + waitTime))))
                    {
                        for(int i = 0; i < statusDB.size(); i++)
                        {
                            ArrayList<String> specifiedDBStatus = statusDB.get(i).getHistory();
                            sortie.println("Last status   | " +specifiedDBStatus.get(0));
                            sortie.println("Actual status | " +specifiedDBStatus.get(1));
                        }
                        time = System.currentTimeMillis();
                        /*try {
                            ServerThreadConnection.sleep(waitTime);
                        } catch (InterruptedException ex) {
                            Logger.getLogger(ServerThreadConnection.class.getName()).log(Level.SEVERE, null, ex);
                        }*/
                    }
                }
            }
        }
        catch (IOException ex)
        {
            System.err.println("Error while opening the BufferedReader " + ex);
        }
        finally
        {
            try
            {
                entree.close();
            }
            catch (IOException ex)
            {
                System.err.println("Error while closing the BufferedReader " + ex);
            }
        }
    }
}

Le problème vient de ma boucle infinie. Elle fait travailler le processeur à 50% quand j'ai 1 client et monte au max avec 2 clients.

Ce qui est tout à fait logique. Comme vous pouvez le voir, j'ai essayé de mettre en pause le thread pendant le temps x. Le processeur ne travaille pas à 100% tout le temps mais uniquement pendant le temps nécessaire pour afficher les résultats.

Y aurait-il une autre solution pour effectuer l'affichage aux clients sans pour autant faire rugir le processeur à tout va?

J'ai dû recourir à une "astuces" pour que le "if(System.CurrentTimeMillis() == ... " ne saute pas d'étapes. Sinon une fois sur 2 la condition n'était pas respectée.

Je précise au cas où que je crée mes clients en ouvrant plusieurs consoles et et je me connecte au serveur via telnet.

Merci d'avance.

< Nutella >

[Alkhan]

bonjour,

c'est normal car dans ta boucle while tu ne met pas tes threads en attente donc elles tournent en permanence.

Pour résoudre le problème il faut que tu fasse un wait(long), long étant le temp de pause en milliseconde.

[NutellaPiou]

Oui j'étais parti dans cette idée là, mais je me suis dit qu'il y avait peut-être moyen de faire autrement...

[Alkhan]

je ne vois pas pourquoi tu cherches une autre solution, vu que cela correspond exactement a ce que tu souhaites !

[NutellaPiou]

j'avais juste l'impression que c'était trop farfelu ce que je faisais

Enfin soit, l'utilisation du wait() me fait perdre la connexion, j'ai donc remplacé par le sleep. Le processeur tourne entre 0 et 2% en sommeil et lorsque l'affichage s'effectue, il monte vers 35%.

Merci pour ta réponse

[adiGuba]

Salut,

c'est normal car dans ta boucle while tu ne met pas tes threads en attente donc elles tournent en permanence.

+1

Plus précisément on appelle cela une attente active. C'est à dire que plutôt que d'attendre le CPU passe son temps à vérifier les conditions de la boucle et du if. En fait tu utilises tout le CPU pour attendre (pour être bloqué à 50% je présume que tu as un bi-processeurs ou un processeur bi-coeur).


A titre d'exemple j'ai repris ta boucle juste pour calculer le nombre d'itération :

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
	long waitTime = 2000;
	long time = System.currentTimeMillis();
	long iteration = 0;
 
	while(true)
    {
        if((System.currentTimeMillis() < ((100 + time + waitTime))) && (System.currentTimeMillis() > ((-100 + time + waitTime))))
        {
            break;
        }
 
        iteration++;
    }
 
	System.out.println("iteration : " + iteration);

Ce qui m'a donné comme résultat :

Code :

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

iteration : 27732432

27 millions d'itération et de vérification de conditions... Çà fait cher pour simplement attendre 2 secondes

Pour résoudre le problème il faut que tu fasse un wait(long), long étant le temp de pause en milliseconde.

IL serait préférable d'utiliser Thread.sleep().
wait() sert à la synchronisation entre thread, ce qui est inutile dans le cas présent.


Mais dans les deux cas cela permet de laisser le CPU s'occuper de ses autres tâches pendant ce temps


a++

[NutellaPiou]

Oui j'ai un dual core. Et utiliser un processeur à 100% pour application qui n'est pas très improtante c'était un peu bizarre. J'ai cherché et de fil en aiguille j'ai trouvé d'où ça venait.

Depuis que ça marche, j'ai fait pas mal de tests. Jusqu'à 4 clients et ya plus de soucis. J'ai même testé avec 2 clients simultanés et il n'y a qu'un coeur qui est dédié à l'applic, logique =)

Merci & Shibby