style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

como testear mi listener java

como puedo realiza unas pruebas a mi listener de cuantas conexiones puede, es que actualmente se me conectan como 600 o 800 equipos a mi listener pero en ciertos momentos varios se me quedan si conexion y cuando algo telnet 192.168.x.x puerto no me conecta y pasa como con el 15 0 n20 % de las conexiones

mi server es algo sencillo:

public class ServidorService

{
    private ServerSocket serverSocket;
    private Socket socket;
    private Monitor monitor;
    private ArrayList<String> terminal = new ArrayList<String>();

    public ServidorService()
    {

      serverSocket=null;
      socket=null;
      DefaultListModel modelo = new DefaultListModel();
        try {        
           
            serverSocket = new ServerSocket(8888);
       
           
           
              while(true)
              {
       
                   socket = serverSocket.accept();
                   terminal.add(socket.getInetAddress().getHostAddress());
                   new Thread (new ListenerSocket(socket) ).start();
              }
        } catch (IOException ex) {
            Logger.getLogger(ServidorService.class.getName()).log(Level.SEVERE, null, ex);
        }
       
       
       
    }  
}

public class ListenerSocket implements  Runnable{
   
   private  final String ENCODING = "ISO-8859-1";
   private Socket socket;

   private ObjectOutputStream outputObejct;
   private ObjectInputStream inputObject;
   
   
   private DataOutputStream outputdata;
   private DataInputStream  inputdata;
 
   
   //private InputStreamReader inputl;
   
   //version 3 en Uso
   private BufferedReader bufferInput;
 
   
    private BufferedReader entrada;
    private PrintStream salida;
    private InputStream out;
    private LoteriaBussines lot;
    private Monitor mon;
   
    public ListenerSocket(Socket socket, Monitor m)
    {
        this.mon=m;
       
       
        try {
            this.socket = socket;
            mon.getLista().append(this.socket.getInetAddress().getHostAddress() +"\n");
            entrada = new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
            salida =  new PrintStream(this.socket.getOutputStream());        
            lot = new LoteriaBussines();
       
        } catch (IOException ex) {
            Logger.getLogger(ListenerSocket.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
   
   
   

    @Override
    public void run()
           
           
    {  
        try {
            String msg;
            String tramaSalida;
       
           
             
                 while ((msg=entrada.readLine())!=null){
                  .....
.......
......

...}
}
}    

que me recomiendan hacer???
como puedo testear para saber cuantos equipos se conectan???
como puedo migrar mi listener actual aun pool de conexiones????

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de ezamudio

pues...

Para saber cuántos equipos se conectan debes llevar la cuenta bien en tu server. Actualmente no sabes porque simplemente aceptas una nueva conexión y echas a andar un hilo; si las conexiones se aceptan desde el hilo principal y cada conexión usa solamente un hilo entonces puedes contar los hilos y ya, puesto que tienes un hilo por conexión; hay varias herramientas para eso. Pero si no hay relación directa entre conexiones e hilos entonces tienes que llevar un registro de las conexiones, simplemente un contador o un mapa o un Set o algo donde sepas cuántas conexiones hay (incrementar contador con conexión nueva, decrementar cuando se cierra - es más difícil de lo que parece, por la parte de SIEMPRE saber cuando se cierra la conexión).

Por lo de pool de conexiones, supongo que te refieres a las conexiones de tus clientes. Eso no lo vas a poder hacer. Pero puedes usar un pool de hilos para atender a las conexiones. Una manera sencilla es crear un cached pool con la clase Executors:

ThreadPoolExecutor tpool = (ThreadPoolExecutor)Executors.newCachedThreadPool();
tpool.setMaximumPoolSize(100);//nunca usará más de 100 hilos
//y en vez de crear un hilo con tu listener haces esto
tpool.execute(new ListenerSocket(socket));

El problema aquí es que vas a estar encolando las nuevas conexiones y si hay hilos disponibles pues se procesan de inmediato pero si no, ahí se van a quedar esperando un rato. Tendrás que estar afinando a mano el tamaño del pool para que no sea muy largo el tiempo de espera. Pero lo raro es que dices que ya de repente algunas conexiones se atoran; has revisado el log en el server? Algo que te puede estar pasando es que ya no se pueden abrir más sockets, revisa si no se arrojan excepciones en el server que digan algo de que no se pueden abrir más file descriptors (si es que estás en Linux o *nix) - de ser así, debes incrementar los ulimits para que se puedan abrir más file descriptors (cada socket en unix usa un file descriptor porque todo es un archivo).

Otra opción es que definas una capacidad máxima y en tu ciclo donde aceptas conexiones, revisar si las conexiones actuales ya llegaron al límite establecido, y de ser así, tienes que usar algo en vez del ListenerSocket, que simplemente la maneje dando un aviso de que ya está saturado el sistema y que intenten conectarse más tarde (y cierren el socket de inmediato y ya). O hasta puedes hacer eso de manera síncrona en el mismo ciclo del accept, sin abrir otro hilo...

el server

el server es windows 7

como podria afinar que cantidad de hilos necesito??

si digo que mi hora maxima de transacciones se conectan las 800 maquinas a la vez, como determino cuantos hilos seran necesario para que no se queden esperando un largo tiempo.

desde mi cliente

desde mi clientes se conecta a mi servidor asi:

 
this.service= new ClienteService();
            this.socket=this.service.conect();
            this.bufferInput = new BufferedReader(new InputStreamReader(socket.getInputStream()));
               
            Thread thread = new Thread(this);
            thread.start();

que tan buena opcion esa hcaerlo asi?

pero si utilizo

ThreadPoolExecutor tpool = (ThreadPoolExecutor)Executors.newCachedThreadPool();
tpool.setMaximumPoolSize(100);//nunca usará más de 100 hilos
//y en vez de crear un hilo con tu listener haces esto
tpool.execute(new ListenerSocket(socket));

desde mi cliente serial de la mismo forma que lo estoy haciendo?

problemas

cunado aplico

ThreadPoolExecutor tpool = (ThreadPoolExecutor)Executors.newCachedThreadPool();
tpool.setMaximumPoolSize(100);//nunca usará más de 100 hilos
//y en vez de crear un hilo con tu listener haces esto
tpool.execute(new ListenerSocket(socket));

mi server corre normal pero cuando un cliente intenta comunicarse con el lanza una excepcion
Exception in thread "Thread-3" java.lang.StringIndexOutOfBoundsException: String index out of range: -1
que no me lanza cuando hago

new Thread (new ListenerSocket(socket) ).start();

Puedes usar JMeter para

Puedes usar JMeter para probar carga.

No encuentro la referencia pero usar un hilo por conexión puede no dar el mejor rendimiento porque el sistema operativo pasa mucho tiempo cambiando el turno de los hilos. Entre mas conexiones tengas, mas hilos se crean y mas lento responde cada uno cada vez.

Una alternativa es tener un solo hilo por procesador (finalmente es lo que tu maquina puede manejar ) y terminar lo mas rápido posible con la petición,. Si una petición de tarda mucho puedes cancela su ejecución y darle oportunidad a otro.

Por ejemplo Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()); ) tienes hasta un máximo de N hilos trabajando y el resto espera en una cola ( asi no tienes un OutOfBoundsException ) conforme se van desocupando los hilos lo encolado se va procesando.

De esa forma en vez de tener 2 cpu (por ejempo en una computadora con 2 cores) atendiendo 800 hilos y tardando segundos o hasta minutos por cada hilo, puedes tener 2 cpu's atendiendo solo 2 hilos y cada peticion es atendida en milisegundos ( aunque pase algun tiempo en la cola sin ser atendido )

pero 800 conexiones

.... como dice si me llegan 800 peticiones me atiende 2 y me deja en cola 798???
digamos que esas dos peticones me las atiende en medio segundo las demas la ultima peticion tendria que esperar 200 seg ????

como determino cuantos hilos..

que operacion o como determino cuantos hilos necesito para

en el codigo que das

ThreadPoolExecutor tpool = (ThreadPoolExecutor)Executors.newCachedThreadPool();
tpool.setMaximumPoolSize(100);//nunca usará más de 100 hilos
//y en vez de crear un hilo con tu listener haces esto
tpool.execute(new ListenerSocket(socket));

se establecio maximo 100 hilos, pero en mi caso son 800 o mas conexiones y si en mi horas pico todos mandan peticiones a la vez, como determino que el server va a tender todas las peticiones y la cola de peticiones no va ser tan larga la espera teniendo en cuenta que puedo tener maximo una espera de de 30 o 40 seg.

No medio segundo ( que son

No medio segundo ( que son 500 ms ), sino 10 -20 ms, entonces atendería 50 por segundo y procesaría todas en unos 16 segundos en total.

Incluso si llegaran otras 800, ( o 2,400 ) tardaría un minuto. Mientras que con 1 thread por conexión, lo mas probable es que al llegar a 2,400 el procesador simplemente se bloqueara y ya no procesara nada ( ni en un minuto ni nunca )

Pero, para no suponer cosas, lo mejor seria que hicieras una prueba de concepto y revisar el verdadero rendimiento. Te serviría incluso para desacoplar el servidor del trabajo que hay que hacer.

si el asusnto era..

es este caso tengo maximo 100 hilos para atender 800 o mas conexiones

ThreadPoolExecutor tpool = (ThreadPoolExecutor)Executors.newCachedThreadPool();
tpool.setMaximumPoolSize(100);//nunca usará más de 100 hilos
//y en vez de crear un hilo con tu listener haces esto
tpool.execute(new ListenerSocket(socket));

y tu menciones

Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

que diferencias hay entre ambas???
en caso que fueras 2400 peticiones como tu dices como seria el rendimiento en el primer caso???
y el segundo caso???

En el primero tienes 2

En el primero tienes 2 procesadores ( suponiendo que tuvieras una máquina con dos procesadores lo cual es muy raro en estos días ) manejando 100 hilos. En el segundo tendrias la misma máquina manejando un solo hilo por CPU

Cuando hice este ejercicio hace como un año, el usar un hilo por CPU me dio el mejor rendimiento que usando 10, 20 100 o indeterminado numero de hilos. Pero ese fue en mi caso, en el tuyo y dependiendo de lo que haga tu servidor puede variar. Para saber la respuesta correcta,implementalo y mide.

Imagen de ezamudio

depende

Eso de usar un hilo por CPU es lo más recomendable si no hay dependencias con el exterior. Pero si estás aceptando conexiones y encolándolas, es mejor tener más hilos, para poder aceptar más conexiones en vez de dejarlas simplemente esperando.

De cualquier forma, este esquema no escala bien a cientos de conexiones cuando quieres tenerlas abiertas e inactivas durante varios segundos. Para eso lo mejor sería que uses java.nio

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">