Discussion :

[cyclopsnet]

Bonjour,
J'ai fait un ServerSocketChannel qui traite des connexion client , et save les messages reçu dans un fichier.
J'attaque ce server avec une classe qui lance 20 Threads qui créent des sockets et envoient des messages.
Après environ 1 heure de traitement j'ai l'exception Too many open file .
Open file system : 32000.
Voila on thread Serveur :

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
private class StartingServer extends Thread {
 
		public void run() {
 
			startServer(server, selector);
		}
 
		private void startServer(ServerSocketChannel server, final Selector selector) {
 
			while (isRunning) {
 
				try {
					selector.select();
					Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
 
					while (keys.hasNext()) {
 
 
						SelectionKey key = keys.next();
						keys.remove();
 
						if (!key.isValid()) {
							continue;
						}
						try {
							//l'évenement correspond à une acceptation de connexion
							if(key.isAcceptable()) {
 
								SocketChannel channel = server.accept();
								channel.configureBlocking(false);
								channel.register(selector, SelectionKey.OP_READ);
 
							}
							//l'évenement correspond à une lecture
							else if(key.isReadable()) {
 
								SocketChannel client = (SocketChannel) key.channel();
 
								TrameManager manager = (TrameManager)key.attachment();
 
								if(manager == null) {
 
										SessionSocket ss = new SessionSocket(client.socket());
										manager = (TrameManager) Introspection.newInstance(managerClassName, new ByteArrayOutputStream(), ss , this.getClass().getClassLoader());
 
									key.attach(manager);
								}
 
								String msg = null;
 
								msg = manager.doRead(doRead(key , manager.getBuffer()));
 
								if(!StringUtils.isEmpty(msg)) {
									putMsgInQueue(msg);
									key.interestOps(SelectionKey.OP_WRITE) ;
								}
 
							}
							//l'évenement correspond à l'écriture
							else if(key.isWritable()) {
 
								TrameManager manager = (TrameManager)key.attachment();
								doWrite(key , manager.doWrite());
 
							}
						} catch (IOException e) {
							fireAlarm(e, "Exception in channel");
							key.channel().close();
							key.attach(null);
							key.cancel();
						}catch (IntrospectionException e) {
							throw new IFException(e, "IntrospectionException");
						}
					}
				} catch (ClosedChannelException e) {
					fireAlarm(e, "Exception in closing channel");
				} catch (IOException e) {
					fireAlarm(e, "Exception in channel");
				}catch (IFException e) {
					fireAlarm(e, "IntrospectionException");
 
				}
			}
		}
	}

Puis-je avoir votre aide pour résoudre ce problème

[thelvin]

Ben, 'faudrait songer à les fermer, les sockets.

Tant que tu y es, vérifier si tu fermes bien les fichiers, aussi.

[cyclopsnet]

Les sockets sont fermées côté client , voila la classe client :

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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
public class Client
{
    private static int    _port;
    private static String    _host;
    private  int _nbClients;
    private static String _path = "test/OE/TEST/";
 
    public Client(int port, String host, int nbClients) {
 
	   _nbClients = ( nbClients >= 1 ) ? nbClients : 1;
       _port   = (port >= 1) ? port : 10081;
       _host = (host != null && !host.equals("")) ? host : "localhost";
 
       for(int i=0; i<_nbClients; i++)
       {   		
          new Reader(i).start();
 
       }
 
	}
 
    /**
     * @param i
     * @return 
     * @throws IOException 
     */
    public static BufferedReader openFile(int i) throws IOException{
    	String filename = _path+"TEST_"+i+".csv";
		try {			
			return new BufferedReader(new FileReader(filename));
 
		} catch (IOException e) {
			throw new IOException(filename + " is not found.");
		} 
    }
 
    /**
     * @return current time
     */
    public static String getCurrentDate(){
    	DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
    	Calendar cal = Calendar.getInstance();
    	return dateFormat.format(cal.getTime());
    }
 
    private class Reader extends Thread {
    	int id;
 
 
	    public Reader(int i) {
	    	id=i;
		}
 
		public void run() {		
 
			System.out.println( getCurrentDate() + " : " + Reader.currentThread().getName() + " started ...");
			BufferedReader br = null;   
			try {
 
				while(true){
 
					br = openFile(id);
					int nbLine = 0;
					while(true){
 
						/*****************************************/
						/**    Send the message to the server   **/
						/*****************************************/
						String line = br.readLine();					
						if (line == null) break;
 
						nbLine++;
						Socket _socket = new Socket(_host, _port);
						PrintWriter output = new PrintWriter(new BufferedWriter(new OutputStreamWriter(_socket.getOutputStream())), true);
						output.println(line);					
						output.flush();
 
						/*****************************************/
						/**  Read the response from the server  **/
						/*****************************************/
						InputStream from_server = _socket.getInputStream();
						OutputStream out = new ByteArrayOutputStream();
 
						byte[] buffer = new byte[4096];
 
					   	out.write(buffer, 0, from_server.read(buffer));
					  // 	System.out.println(out.toString());
						from_server.close();   
 
				    	_socket.close();
 
				    	if (nbLine%100 == 0){
				    	//	sleep(5);
				    		System.out.println(Reader.currentThread().getName() + " : " + nbLine + " messages was sent to serverSocket.");
				    	}
					}
					br.close();
 
				}	
 
			} catch (UnknownHostException e) {
				e.printStackTrace();
			}catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} 
 
			System.out.println(getCurrentDate() + " : " + Reader.currentThread().getName() +" stopped ...");
	   	 	Reader.currentThread().interrupt();
	    }
    }
 
}

Est que je dois les fermer aussi côté serveur ?

[thelvin]

Bonne question. Que te dit ton test de charge ?

Oui, quand une machine lit de l'IO, elle le fait après avoir ouvert cette IO et doit donc la fermer. Peu importe qu'il y ait une autre machine en face qui doit faire exactement la même chose.

[cyclopsnet]

La classe Client qui est utilisée pour lancer le test de charge dit que les sockets se ferme après la reception de la réponse serveur, mais comment je peux être sur côté client que le socket est bien fermer et les ressources sont libérées ?

Dans mon cas mon serveur ne doit pas fermer le connexion car il sait pas si le client veut envoyer d'autres infos ou non , il reste en mode d'écoute.

[thelvin]

Je me moquais de toi. Ton test de charge te dit que tu as un gros problème dans la situation actuelle où le serveur ne ferme pas les sockets. Donc oui le serveur doit fermer les sockets !
Je reconnais que la science c'est quand même pas aussi simple que ça, mais en l'occurrence je t'enlève tes doutes : quand on connaît quoi que ce soit à la gestion des IOs, on sait que tout ce qu'on lit ou écrit on l'a ouvert et donc on doit le fermer. Que le client s'acquitte ou non de cette obligation qu'il a de le faire pour lui, ne concerne pas le serveur qui a lui aussi cette même obligation.

mais comment je peux être sur côté client que le socket est bien fermer et les ressources sont libérées ?

L'emploi de try-with-resource est en général la bonne approche.
Après tu peux toujours regarder ce que dit netstat.

Dans mon cas mon serveur ne doit pas fermer le connexion car il sait pas si le client veut envoyer d'autres infos ou non , il reste en mode d'écoute.

Ce qui signifie simplement qu'il ne doit la fermer qu'après que le client l'ait fermé, ce qui se voit du fait que read() renvoie un nombre négatif.