Discussion :

[Kevin12]

J'ai conçu un serveur qui peut être amené à un moment donné à gérer un nombre élevé de connexions. La première idée qui m'est venue est de mettre en place un moniteur pour contrôler le nombre de connexions simultanées.

Avant d'aller loin je voudrais d'abord avoir votre avis sur cette idée et savoir comment mettre en place (juste les grandes lignes) un moniteur pour les communications de type réseau.

[tchize_]

si c'est un serveur, il suffit simplement que, passé un certain nombre de thread actif, tu arrête d'appeler accept() sur la socket serveur. Tu attends alors sur un semaphore et quand un thread a fini son boulot, il a juste a abaisser le sémaphore et tu peux de nouveau faire des accept().

[Kevin12]

Tu attends alors sur un semaphore et quand un thread a fini son boulot, il a juste a abaisser le sémaphore et tu peux de nouveau faire des accept().

C'est dans un main que je fait mon accept(). Le problème est qu'à ce niveau il est impossible d'utiliser un wait().

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
public static void main(String[] args) {
		ServerSocket svr; // le socket serveur, socket d'écoute
		Socket connexionCourante; // la connexion courante avec un client
			try {
				svr = new ServerSocket(Peer.PORT);
				while (true) {
					// attends une connexion
					connexionCourante = svr.accept();
					Peer peer = new Peer(connexionCourante);
					peer.start();
				}
			} catch (IOException e) {
				System.err.println("Exception : " + e);
			}
 
	}

[tchize_]

bien sur que si tu peux. le wait n'est pas nécessairement à utiliser sur "this" (qui n'existe pas de fait dans ton main) mais sur n'importe quel objet qui te servira de sémaphore. Cet objet doit naturellement être partagé entre ton main et les threads qui gèrent tes connections

Y a pas mal de doc dans le thinking in java sur la gestion des thread il me semble. De plus, java.util.concurrent fourni, dans les jvm récentes, toute une chiée d'objets bien utiles pour la gestion des threads.

[Kevin12]

Merci, je me suis finalement penché vers les moniteurs. Je mets ici le code au cas où il ça intéresserait d'autres personnes. Les critiques et suggestions seraient les bienvenus.

Le moniteur :

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
 
public class ConnMonitor {
	private int nbMax = 30; // nombre maximal de connexion autorisé
	private int nbConn; // nombre de connexion en cours
	private Condition acceptConn;
	private ReentrantLock verrou;
	private boolean isFull;
 
	/**
         * 
         */
	public ConnMonitor() {
		super();
		this.nbConn = 0;
		this.verrou = new ReentrantLock();
		this.acceptConn = verrou.newCondition();
		this.isFull = false;
	}
 
	public void inc() {
		verrou.lock();
		while (isFull) {
			try {
				acceptConn.await();
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
		nbConn++;
		if (nbConn >= nbMax){
			isFull = true;
			System.out.println("Nombre maximal de connexions atteint"); 
		}
 
		verrou.unlock();
	}
 
	public void dec() {
		verrou.lock();
		nbConn--;
		if (nbConn < nbMax) {
			this.isFull = false;
			this.acceptConn.signal();
		}
		verrou.unlock();
	}
}

Le main

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
public static void main(String[] args) {
		//...

		ConnMonitor monitor = new ConnMonitor(); 
			try {
				//...
				while (true) {
					monitor.inc();
					// attends une connexion
					connexionCourante = svr.accept();
					Peer peer = new Peer(connexionCourante,monitor);
					peer.start();
				}
			} catch (IOException e) {
				System.err.println("Exception : " + e);
			}
		
	}

Le Peer

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
Class Peer extends Thread{
       //....
       private ConnMonitor monitor;
 
 
	public  Peer(Socket connexion, ConnMonitor monitor)  {
		this.monitor = monitor;
		//...
	}
	run (){
            //...
           this.monitor.dec();
        }
}