IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Entrée/Sortie Java Discussion :

Too many open file durant un test de charge [ServerSocketChannel]


Sujet :

Entrée/Sortie Java

  1. #1
    Membre du Club
    Inscrit en
    Août 2008
    Messages
    184
    Détails du profil
    Informations forums :
    Inscription : Août 2008
    Messages : 184
    Points : 49
    Points
    49
    Par défaut Too many open file durant un test de charge [ServerSocketChannel]
    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

  2. #2
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 547
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 547
    Points : 21 602
    Points
    21 602
    Par défaut
    Ben, 'faudrait songer à les fermer, les sockets.

    Tant que tu y es, vérifier si tu fermes bien les fichiers, aussi.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  3. #3
    Membre du Club
    Inscrit en
    Août 2008
    Messages
    184
    Détails du profil
    Informations forums :
    Inscription : Août 2008
    Messages : 184
    Points : 49
    Points
    49
    Par défaut
    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 ?

  4. #4
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 547
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 547
    Points : 21 602
    Points
    21 602
    Par défaut
    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.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  5. #5
    Membre du Club
    Inscrit en
    Août 2008
    Messages
    184
    Détails du profil
    Informations forums :
    Inscription : Août 2008
    Messages : 184
    Points : 49
    Points
    49
    Par défaut
    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.

  6. #6
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 547
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 547
    Points : 21 602
    Points
    21 602
    Par défaut
    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.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  7. #7
    Membre du Club
    Inscrit en
    Août 2008
    Messages
    184
    Détails du profil
    Informations forums :
    Inscription : Août 2008
    Messages : 184
    Points : 49
    Points
    49
    Par défaut
    Mais si le read() renvoit un nombre négatif ça veut dire que le buffer est vide mais pas obligatoirement que le client à fermer ça connexion

  8. #8
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 547
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 547
    Points : 21 602
    Points
    21 602
    Par défaut
    Où ça ? Moi je te parle de la Socket. Que dit la JavaDoc de read() ?
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  9. #9
    Expert éminent sénior
    Avatar de tchize_
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2007
    Messages
    25 481
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Avril 2007
    Messages : 25 481
    Points : 48 806
    Points
    48 806
    Par défaut
    Pour confirmer ce qui t'as été dit: oui, le serveur doit EXPLICITEMENT fermer la socket, personnes ne le fera pour lui. La question que te pose c'est "quand, comment puis-je savoir que c'est le moment?"

    La plupart des protocoles réseau s'acquittent de cette tâche en combinant deux méthodes:
    1) établir un protocole qui permet de le savoir. Par exemple en ayant le client qui envoie un message style "au revoir" à la fin de la communication
    2) établir un heartbeat, un keepalive ou quelque chose de similaire et en déconnectant les clients ne répondant pas au bout de X secondes. Ceci afin d'identifier les clients qui ne disent jamais au revoir et / ou les clients qui ont crashé

  10. #10
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 547
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 547
    Points : 21 602
    Points
    21 602
    Par défaut
    Citation Envoyé par tchize_ Voir le message
    1) établir un protocole qui permet de le savoir. Par exemple en ayant le client qui envoie un message style "au revoir" à la fin de la communication
    À noter que TCP/IP inclut un message de ce genre et que Java le représente dans ses Socket, avec son mécanisme habituel de "fin de flux d'entrée" (end of stream.)
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  11. #11
    Membre du Club
    Inscrit en
    Août 2008
    Messages
    184
    Détails du profil
    Informations forums :
    Inscription : Août 2008
    Messages : 184
    Points : 49
    Points
    49
    Par défaut
    J'ai testé le cas d'un read() qui retourne -1 ; mais il indique seulement que le serveur à reçu tout le message envoyé
    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
     
    public ByteArrayOutputStream doRead(SelectionKey key , ByteArrayOutputStream reader) throws IOException {
     
    		SocketChannel client = (SocketChannel) key.channel();
     
    		ByteBuffer readBuffer = ByteBuffer.allocate(2048);
    		readBuffer.clear();
     
    		int numread = 0, capacity = 0;
     
    		while (isRunning) {
     
    			numread = client.read( readBuffer );
    			System.out.println("Bit : "+numread);
    			if(numread > 0)
    				capacity = numread;
     
    			if (numread ==0) {
    				break;
    			}
    			else if(numread == -1)
    				throw new IOException();
     
     
    		}
     
    		readBuffer.flip() ;
     
    		reader.write(readBuffer.array(), 0, capacity);
     
    		return reader;
    	}
    J'ai eu le -1 sans que je ferme ma socket client depuis la classe de test , alors si je ferme la socket quand read()==-1 , et le client veut envoyer un autre truc sur la meme connexion alors Boom java.net.SocketException: Socket is closed

  12. #12
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 547
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 547
    Points : 21 602
    Points
    21 602
    Par défaut
    Désolé mais je te crois pas. Montre-nous.
    "Reçu tout le message envoyé" ça existe pas. Mais si la socket a plus rien à lire sans bloquer, elle indique zéro, pas -1, pas autre chose.

    Enfin, si c'est pendant tes tests de charge, le client peut très bien échouer à maintenir la socket, et passer dans le code de fermeture sans que ce soit ce que tu as cherché à faire. La surcharge, ça marche pas, c'est normal.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  13. #13
    Membre du Club
    Inscrit en
    Août 2008
    Messages
    184
    Détails du profil
    Informations forums :
    Inscription : Août 2008
    Messages : 184
    Points : 49
    Points
    49
    Par défaut
    Voila ma classe de test :
    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
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
     
    package com.geoloc.test;
     
    import java.io.*;
    import java.net.Socket;
    import java.net.UnknownHostException;
    import java.text.DateFormat;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.Scanner;
     
    public class Client
    {
        private static int    _port;
        private static String    _host;
        private  int _nbClients;
        private static String _path = "test/geolocOE/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;   
    			PrintWriter output = null;
    			InputStream from_server = null;
    			OutputStream out = 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);
    						output = new PrintWriter(new BufferedWriter(new OutputStreamWriter(_socket.getOutputStream())), true);
    						output.println(line);					
    						output.flush();
     
    						/*****************************************/
    						/**  Read the response from the server  **/
    						/*****************************************/
    						from_server = _socket.getInputStream();
    						out = new ByteArrayOutputStream();
     
    						byte[] buffer = new byte[4096];
     
    					   	out.write(buffer, 0, from_server.read(buffer));
    					   	System.out.println(out.toString());
    						from_server.close();   
     
    						output = new PrintWriter(new BufferedWriter(new OutputStreamWriter(_socket.getOutputStream())), true);
    						output.println("TEST\n");					
    						output.flush();
     
    						from_server = _socket.getInputStream();
    						out = new ByteArrayOutputStream();
     
    						byte[] _buffer = new byte[4096];
     
    					   	out.write(buffer, 0, from_server.read(_buffer));
    					   	System.out.println(out.toString());
    						from_server.close();  
     
    						System.out.println(Reader.currentThread().getName() + " : " + nbLine + " messages was sent to serverSocket.");
     
    				    	_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();
    	    }
        }
     
    }
    Voila les logs :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
     
    2014/06/11 16:24:03 : Thread-0 started ...
    ACK
    java.net.SocketException: Socket is closed
    	at java.net.Socket.getOutputStream(Socket.java:828)
    	at com.geoloc.test.Client$Reader.run(Client.java:103)
    2014/06/11 16:24:03 : Thread-0 stopped ...
    Le client envoie une chaine et reçoit ACK puis il veut envoyer un autre message , Bom Socket is closed !

    Dans le classe serveur (le dernier post) qui j'ai un read==-1 je throw un IOException qui ferme le channel....

  14. #14
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 547
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 547
    Points : 21 602
    Points
    21 602
    Par défaut
    J'ai eu le -1 sans que je ferme ma socket client depuis la classe de test
    Au cas où tu te demandes ce que veut dire le verbe close, c'est de l'anglais, ça veut dire fermer.

    Jamais dire des trucs. Toujours les montrer.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  15. #15
    Membre du Club
    Inscrit en
    Août 2008
    Messages
    184
    Détails du profil
    Informations forums :
    Inscription : Août 2008
    Messages : 184
    Points : 49
    Points
    49
    Par défaut
    Oki , alors le fait de fermer le InputStream ferme la socket , je pensais que le seul moyen pour fermer une socket c'est socket.close
    Merci thelvin.

  16. #16
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 547
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 547
    Points : 21 602
    Points
    21 602
    Par défaut
    Euuuuh, voui, mais, tu as sans doute remarqué que tu l'as obtenu en faisant getInputStream() sur la socket ? Tu te rappelles, c'est pour ça que ce qu'il lit, c'est ce qui vient du port connecté avec la socket ?
    Concrètement, quand tu as fermé l'InputStream, tu pensais que tu demandais quoi, au juste ?
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  17. #17
    Membre du Club
    Inscrit en
    Août 2008
    Messages
    184
    Détails du profil
    Informations forums :
    Inscription : Août 2008
    Messages : 184
    Points : 49
    Points
    49
    Par défaut
    Que je ferme seulement le flux de lecture , mais la socket reste connecté au serveur

  18. #18
    Expert éminent sénior
    Avatar de tchize_
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2007
    Messages
    25 481
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44
    Localisation : Belgique

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Avril 2007
    Messages : 25 481
    Points : 48 806
    Points
    48 806
    Par défaut
    Closing the returned InputStream will close the associated socket.
    C'est un peu marqué clairement dans la doc quand même

  19. #19
    Modérateur

    Profil pro
    Inscrit en
    Septembre 2004
    Messages
    12 547
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Septembre 2004
    Messages : 12 547
    Points : 21 602
    Points
    21 602
    Par défaut
    Citation Envoyé par cyclopsnet Voir le message
    Que je ferme seulement le flux de lecture , mais la socket reste connecté au serveur
    Je veux dire, "fermer le flux de lecture," ça veut dire quoi concrètement, sur une Socket ?
    Si c'est pas la Socket elle-même il y a rien à fermer... Une connexion TCP/IP c'est une connexion TCP/IP.
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. Lecture de properties - Too many open files
    Par Romz_Java dans le forum Collection et Stream
    Réponses: 8
    Dernier message: 08/07/2011, 12h39
  2. [Tomcat 5.0.28] ZipException: Too many open files
    Par maloups dans le forum Tomcat et TomEE
    Réponses: 0
    Dernier message: 14/11/2008, 17h47
  3. Too many open files
    Par ppmaster dans le forum Weblogic
    Réponses: 1
    Dernier message: 11/09/2007, 15h17
  4. [Système] failed to open stream: Too many open files
    Par shamanlinks dans le forum Langage
    Réponses: 7
    Dernier message: 23/05/2006, 12h59
  5. Pb avec socket - too many open files
    Par be_tnt dans le forum Réseau
    Réponses: 16
    Dernier message: 17/05/2006, 11h46

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo