Synchronisation de connexions

Version imprimable

08/04/2009, 14h35
Kevin12

Synchronisation de connexions

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.
08/04/2009, 15h10
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().

Citation:

Envoyé par tchize_

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:

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); } }

14/04/2009, 20h39
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.

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:

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:

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:

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();
        }
}