Discussion :

[reacen]

Bonjour,

Je débute en JAVA. Et je cherche à créer une class qui Bufferise les packets, et les envoies en multithreads. (pour un serveur MMORPG).

Voici un exemple de ce que je veux faire:

Code :

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

1
2
3
4
5
6
7
8
9
 
 
public class buffer{
 
	private Map<PrintWriter,String> _buffer = new TreeMap<PrintWriter,String>();
 
	public void addPacket(PrintWriter client, String data); // Ajoute un packet à la liste. (_buffer)
	public void sendPacket(); // Traite le dernier packet et le retire de la liste.
}

addPacket(): Va ajouter un client plus son packet à la collection _buffer.
sendPacket(): Doit être appelé par un Pool de 6 Threads à la fois. La méthode Prends un client de la collection _buffer et lui envoie son packet, puis le retire de la liste.


Bref, tout ça parait simple et facile à faire, mais le problème que j'ai, c'est que dans la méthode sendPacket(); il y a quelques instructions qui mettent des fois du temps, et ça peut varier. Entre 0 ms à 2 minutes.

Ce qui fait, les 6 threads qui appellent la méthode de la class vont finir par tous planter à un moment donné, et le serveur ne va plus répondre de packets aux clients, car les 6 threads seront tous occupés à attendre l’exécution de la méthode.

Ce que je veux savoir c'est: Est-ce qu'il existe un moyen rapide de dire au thread d’exécuter sendPacket() et ne pas dépasser 100 millisecondes ?
Ce que je veux dire par "rapide" c'est que ça doit être rapide et optimisé, car le serveur doit supporter les 4.000 connectés simultanés. Donc les 6 threads auront un travaille énorme, et sendPacket() sera appelé une centaines de fois par seconde.

2éme question: Map<PrintWriter,String> Est-ce un bon choix pour ce genre de travaille? Est-ce multithread safe? Est-ce assez rapide?
----

Bref, je n'ai toujours pas créer cette class, tout ça est toujours en théorie je cherche juste à avoir des idées avant de me lancer sur son codage. Je débute toujours en Java et je ne veux pas avoir de mauvaise surprises après. N'hésitez pas si vous avez des conseils, ou critiques à faire ou si vous avez une meilleur idée pour remplacer cette class. C'est très important pour moi, merci.

[fallo]

Excuses moi, mais si tu debutes, ne te lance pas dans l'ecriture d'un MMORPG, vraiment.

sinon, y'a des choses qui existent, je n'ai jamais regardé mais a mon avis, tu devrais, JME (edit: jmonkeyengine) a choisis une librairie de gestion du reseau multijeur qui semble correcte, ca sera probablement suffisant.

concernant ta classe, utilise une concurenthashmap plutot qu'un tree map

sendpacket ne doit pas faire autre chose que d'envoyer des packets tout pres, sinon c'est pas bon.
chaque execution doit etre tres courte par construction.
etudie les Nio, ca t'evitera peu etre d'avoir besoin de ta classe.
regarde la gestion des timeouts de sockets.

etudie les thread et acces concurents, car tu en auras bien besoin.


et surtout distille bien bien ton courrage, tu en auras besoin longtemps

[dinobogan]

J'ajouterai une chose : ne te focalise pas sur Java dès le début.
Construit correctement ton architecture et fait des micro-tests de charge pour simuler 4000 utilisateurs connectés.

[kolodz]

Il est certes important de penser à l'optimisation dès la création de ce genre d'application. Mais il est préférable d'avoir quelque chose qui fonctionne et qui sera lent avec +1 000 utilisateurs. Puis d'optimiser.

Même si je partage l'idée d'utiliser une "librairie de gestion du réseau multijoueur". Il est probable qu'ils aient réalisé cela de manière sérieuse.
*Ils y ont investi du temps que tu n'aura pas à investir.*

Cordialement,
Patrick Kolodziejczyk.

[dinobogan]

Il est certes important de penser à l'optimisation dès la création de ce genre d'application. Mais il est préférable d'avoir quelque chose qui fonctionne et qui sera lent avec +1 000 utilisateurs. Puis d'optimiser.

Selon le projet (et ses contraintes : budget, temps) et la différence entre le fonctionnement du logiciel et le fonctionnement cible, ça n'est pas toujours possible. Parfois, à cause des choix d'architecture et de langage, on arrive au "mur d'optimisation" : il n'est plus possible de faire mieux sans casser une bonne partie du code, ou pire, sans changer de langage et/ou de machine. Ca devient très vite catastrophique pour le projet. C'est pour cela que j'ai évoqué des micro-tests de charge sur les zone de code à risque.
Mais la technique de faire un truc qui fonctionne et ensuite d'optimiser est largement utilisée aussi, tu as raison.

[Logan Mauzaize]

1. Remplace ta TreeMap par une IdentityHashMap
2. Tu peux gérer un timeout sur les sockets via l'API des sockets.
3. Si tu utilises un ExecutorService, tu peux gérer un timeout sur la task à l'aide de la méthode get.
4. Une classe thread-safe ne l'est que pour l'invocation d'une méthode. A mon avis, il n'est jamais bon d'utiliser une classe thread-safe, il vaut mieux opter pour des blocs de synchronisation ou des lock.

Exemple de code utilisant une API thread-safe mais dont le code n'est pas thread-safe.

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
 
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
 
public class ThreadSafe {
  public static void main(String[] args) {
    final int size=1000;
    final String key="foo";
    final Map<String, Integer> map = Collections.synchronizedMap(new HashMap<String, Integer>(size));
    final Runnable task = new Runnable() {
      public void run() {
         Integer number = null;
         if (map.containsKey(key)) number = map.get(key);
         else number = Integer.valueOf(0);
         number = Integer.valueOf(number.intValue() + 1);
         map.put(key, number);  
      }
    };
    List<Thread> threads = new LinkedList<Thread>();
    for (int i=0; i < size; i++)
    {
       threads.add(new Thread(task, "Iterator-#" + i));
    }
    for (Thread thread : threads) {
      thread.start();
    }
    for (Thread thread : threads) {
      try {
         thread.join();
      }
      catch (InterruptedException ex) {
         ex.printStackTrace();
      }
    }
    System.out.println("Value after " + size + " iteration(s): " + map.get(key));
  }
}