Serveur de chat, inspiré du tuto

Bonjour,
je débute le Java depuis maintenant 1 semaine.
J'essai de faire un petit serveur de chat utilisant des sockets.
J'ai donc parcouru des sites, des tutoriaux, en particulier Développement d'un serveur Java multi-thread simple
Apres quelques modif perso ca semble fonctionner plutot bien, mais voila je me suis rendu compte que les thread clients sont crées à chaque message envoyé, ce qui me semble assez génant.

je vous présente le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
import java.util.regex.*;
 
public class Projet {
 
	public static void main(String args[]) {		  
		Integer port 	= 35353;
		Server myServer = Server.load(port);	// chargement du serveur
		myServer.start();   // démarrage du serveur
	}
}

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
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
import java.io.*;
import java.net.*;
import java.util.*;
 
public class Server {
	private Vector<PrintWriter> _tabClients = new Vector<PrintWriter>(); // stockage des clients
	private static int _nbClients = 0;	
	private static Server _instance = null;	// singleton
	private int _port;
	private Log _log;
 
	// constructeur privé (singleton)
	private Server(int port) {
		_port 	= port;
		_log	= new LogConsole();
		_log.write("Server init.");
	}
 
	// recupération, chargement du serveur
	public static Server load(int port) {
		if(Server._instance == null)
			Server._instance = new Server(port);
		// si le serveur n'est pas chargé, on crée un nouveau serveur
		return Server._instance;
	}
 
	// démarrage du serveur
	public void start() {
	    try {
	    	_log.write("Server start ...");
		this.listen();	// en attente ...
	    }
	    catch (Exception e) {
	    	_log.write("error while starting.");
	    }
	}
 
	// en attente de flux entrant
	private void listen() {
	    try {	    	
		ServerSocket serverSocket = new ServerSocket(_port);
		while (true)
			new CThread(serverSocket.accept(), this);
			// un thread par flux entrant :s
	    }
	    catch (Exception e) {
	    	_log.write("error while listen.");
	    }
	}
 
	// envoi du flux à tous les clients
	synchronized public void sendAll(String message) {
		PrintWriter out;	// nouvelle sortie
		for (int i = 0; i < _tabClients.size(); i++) {
	    		// pour chaque printWrite du vecteur, on envoi le flux de sortie
	    		out = (PrintWriter) _tabClients.elementAt(i);
	    		if (out != null) {
	    			out.print(message);
	    			out.flush();
	    		}
	   	 }
	}
 
	// suppression de client
	synchronized public void delClient(int i) {
		Server._nbClients--;
		if (_tabClients.elementAt(i) != null) {
			_tabClients.removeElementAt(i);
			System.out.println("suppression client "+i);
		}
	}
 
	// ajout de client
	synchronized public int addClient(PrintWriter out) {
		Server._nbClients++;
		_tabClients.addElement(out);
		System.out.println("ajout client "+(_tabClients.size()-1));
		return _tabClients.size()-1;
	}
}

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
 
import java.net.*;
import java.util.regex.*;
import java.io.*;
 
// chargé de gerer les thread clients
class CThread implements Runnable {
	private Thread _thread;
	private Socket _socket;
	private PrintWriter _out;
	private BufferedReader _in;
	private Server _myServer;
	private int _numClient = 0;
 
	public CThread(Socket s, Server myServer) {
		_myServer = myServer;
		_socket	    = s;
		try {
	    		_out = new PrintWriter(_socket.getOutputStream());
	    		_in   = new BufferedReader(new InputStreamReader(_socket.getInputStream()));			
	    		_numClient = myServer.addClient(_out);
	    	}
	    	catch (IOException e){ }
 
	   	 _thread = new Thread(this);
	    	_thread.start();
	}
 
	public void run() {
		String inputLine  = "";
 
		try {			
			while((inputLine = _in.readLine()) != null) {
				System.out.println(inputLine);
				_myServer.sendAll(inputLine);
			}
		}
		catch (Exception e){ }
		finally {
			try {
				this._myServer.delClient(_numClient);
				_socket.close();
			}
			catch (IOException e){ }
		}
	}
}

La reception et l'envoi sont bons, les clients (en php) recoivent bien.
En plus de ca j'aimerais pouvoir choisir à quels clients envoyer tels messages, et je pense que actuellement c'est le fait d'avoir un thread par client qui me bloque.

Merci à ceux qui ont lu et qui essayeront de m'aider.

Cordialement