• Viernes 8 de Noviembre de 2024, 00:43

Autor Tema:  Duda con BufferedReader  (Leído 2715 veces)

ropel

  • Miembro activo
  • **
  • Mensajes: 32
    • Ver Perfil
Duda con BufferedReader
« en: Jueves 15 de Enero de 2009, 19:56 »
0
Hola a todos,

tengo una duda con respecto al objeto BufferedReader. Yo tengo una instancia de este objeto por el cual leo datos escritos en un socket determinado, es decir, enviados a través de la red. Cada vez que yo escribo la siguiente línea de código:

Código: Text
  1.  
  2. String entrada;
  3. BufferedReader reader;
  4.  
  5. ....
  6. ....
  7.  
  8. entrada = reader.readLine();
  9.  
  10.  

La ejecución de mi programa se detiene hasta que lee una línea completa. Mi pregunta es ¿cómo puedo hacer para que mire si se han enviado datos por ese socket y, en caso positivo procesarlos y en caso negativo no permanecer a la espera, sino que me continúe con el programa? Es decir, lo que pretendo es que me continúe la ejecución si no se han escrito datos, pero que los procese en caso positivo, en lugar de que se quede esperando a la llegada de una línea de datos.

Espero haberme explicado adecuadamente. ¿Alguien me puede ayudar u orientar en este aspecto? Espero que lo que pretendo tenga solución.

Muchas gracias y saludos a todos.

dvinchi666

  • Nuevo Miembro
  • *
  • Mensajes: 6
    • Ver Perfil
Re: Duda con BufferedReader
« Respuesta #1 en: Sábado 17 de Enero de 2009, 03:13 »
0
Analizando un poco. :comp:

lo que unico que se me ocurre es:
    ocupar temporizadores

Arrancas el temporizador justo antes de leer los datos del socket
entonces en otro hilo va aumentando el temporizador hasta cierto valor (timeout) "tiempo de espera maximo para que hayan insertado datos en el socket"

Fragmento de codigo:

Código: Text
  1. //  
  2. //  Timer.java
  3. //  Copyright (c) 1996, Agustin Froufe
  4. //  Todos los derechos reservados.
  5. //  
  6. //  No se asume ninguna  responsabilidad por el  uso o  alteracion  de este
  7. //  software.  Este software se proporciona COMO ES, sin garantia de ningun
  8. //  tipo de su funcionamiento y en ningun caso sera el autor responsable de
  9. //  daños o perjuicios que se deriven del mal uso del software,  aun cuando
  10. //  este haya sido notificado de la posibilidad de dicho daño.
  11. //
  12. //   Compilador: javac 1.0
  13. //        Autor: Agustin Froufe
  14. //     Creacion: 23-Oct-1996  014:53:09
  15. //
  16. //--------------------------------------------------------------------------
  17. //  Esta informacion no es necesariamente definitiva y esta sujeta a cambios
  18. //  que pueden ser incorporados en cualquier momento, sin avisar.
  19. //--------------------------------------------------------------------------
  20.  
  21. import java.lang.*;
  22. import java.util.*;
  23.  
  24. public class Timer implements Runnable {
  25.     private Date inicio,parada;
  26.     private Thread thread = null;
  27.     private int duracion = 0;
  28.     private int duracionAnt = 0;
  29.     private int intervalo = 1000;
  30.     private boolean repeticion = false;
  31.     private boolean enEjecucion = false;
  32.     private Temporizador handler = null;
  33.    
  34.     // Contructor basico, usado por defecto
  35.     Timer() { }
  36.    
  37.  
  38.     // Los siguientes constructores son de conveniencia, porque todas
  39.     // las caracteristicas del timer se pueden ver y modificar a
  40.     // traves de los metodos get y set
  41.     // Constructor de conveniencia que acepta un tiempo de duracion
  42.     Timer( int tiempo ) {
  43.         setDuracion( tiempo );
  44.         }
  45.    
  46.  
  47.     // Constructor de conveniencia que acepta un Temporizador
  48.     Timer( Temporizador Handler ) {
  49.         setHandler( Handler );
  50.         }
  51.    
  52.  
  53.     // Constructor de conveniencia que acepta un temporizador y una
  54.     // duracion
  55.     Timer( int tiempo,Temporizador Handler ) {
  56.         setDuracion( tiempo );
  57.         setHandler( Handler );
  58.         }
  59.      
  60.  
  61.     // Fija el numero se segundos que correra el timer
  62.     public void setDuracion( int tiempo ) {
  63.         duracion = tiempo;
  64.         }
  65.    
  66.  
  67.     // Fija el objeto que ha de ser notificado de los eventos que
  68.     // sucedan al timer
  69.     public void setHandler( Temporizador Handler ) {
  70.         handler = Handler;
  71.         }
  72.    
  73.  
  74.     // Fija el numero de milisegundos entre pulsos del timer
  75.     public void setIntervalo( int Intervalo ) {
  76.         intervalo = Intervalo;
  77.         }
  78.    
  79.  
  80.     // Funciones "get" para recoger los datos de las caracteristicas
  81.     // que se han fijado antes
  82.     public int getDuration() {
  83.         return( duracion );
  84.         }
  85.  
  86.     public Temporizador getHandler() {
  87.         return( handler );
  88.         }
  89.  
  90.     public int getIntervalo() {
  91.         return( intervalo );
  92.         }  
  93.    
  94.  
  95.     // Devuelve el numero de segundos que han transcurrido desde que
  96.     // se arranco el timer
  97.     public int getElapsed() {
  98.          return( calculaLapso( new Date() ) );
  99.         }  
  100.  
  101.  
  102.     // Este metodo permite resetear el timer antes de relanzarlo. Se
  103.     // podria usar el metodo setDuracion, pero este es mas corto
  104.     // y elegante
  105.     public void resetDuracion() {
  106.         duracion = duracionAnt;
  107.         }  
  108.        
  109.  
  110.     // Aqui creamos un nuevo thread para correr el Timer. Lo incializamos
  111.     // con "this" de forma que el metodo run() se llame inmediatamente
  112.     // como comience la ejecucion del thread
  113.     public void start() {
  114.         thread = new Thread( this );
  115.         thread.start();
  116.         }
  117.  
  118.  
  119.     // Aqui almacenamos el momento en que se llama a este metodo.
  120.     // Tambien comprobamos si hay algun Temporizador asociado al Timer
  121.     // que estamos parando, en cuyo caso, notificamos a los observadores
  122.     // de este Timer que lo hemos detenido (para eso esta la interface
  123.     // Temporizador, que debera estar implementada en las clases que
  124.     // miren a este Timer)
  125.     public void stop() {
  126.         enEjecucion = false;
  127.         parada = new Date();
  128.         if ( handler != null )
  129.             handler.timerParado( this );
  130.         }
  131.    
  132.  
  133.     public void run() {
  134.         enEjecucion = true;
  135.         duracionAnt = duracion;
  136.  
  137.         // Arrancamos el Timer y lo notificamos a las clases que esten
  138.         // poendientes
  139.         inicio = new Date();
  140.         if( handler != null )
  141.             handler.timerArrancado( this );
  142.  
  143.         while( enEjecucion )
  144.             {
  145.             // Esperamos el tiempo que nos hayan dicho en la configuracion
  146.             // del intervalo
  147.             try {
  148.                 esperar( intervalo );
  149.             } catch( InterruptedException e ) {
  150.                 return;
  151.                 }
  152.              
  153.             // Cuando se cumple el intervalo, avisamos a las clases que
  154.             // esten pendientes. Si esas clases no quieren hacer nada
  155.             // con este evento periodico, es suficiente con que no lo
  156.             // sobrecarguen, que se quede vacio
  157.             if( handler != null )
  158.                 handler.timerIntervalo( this );
  159.              
  160.             // Si no indicamos una duracion para el Timer, estara
  161.             // corriendo indefinidamente
  162.             if( duracion > 0 )
  163.                 {
  164.                 // Comprobamos si el Timer esta muerto ya, para no
  165.                 // tener que matarlo
  166.                 if( estaMuerto() )
  167.                     {
  168.                     // Si esta muerto, lo propagamos
  169.                     if( handler != null )
  170.                         handler.timerMuerto( this );              
  171.                
  172.                     // Aqui comprobamos si se quiere una repeticion
  173.                     // automatica, en cuyo caso, volvemos a arrancar
  174.                     // el Timer
  175.                     if( repeticion )
  176.                         {
  177.                         enEjecucion = true;
  178.                         inicio = new Date();
  179.                         if( handler != null )
  180.                             handler.timerArrancado( this );  
  181.                         }
  182.                     else
  183.                         {
  184.                         enEjecucion = false;
  185.                         }
  186.                     }
  187.                 }
  188.             }
  189.         }    
  190.    
  191.     // Metodos que nos informan del estado del Timer
  192.     public boolean estaCorriendo() {
  193.         return( enEjecucion );
  194.         }
  195.    
  196.     public boolean estaParado() {
  197.         return( !enEjecucion );
  198.         }
  199.    
  200.  
  201.     public boolean estaMuerto() {
  202.         int segundos = 0;
  203.  
  204.         // Calculamos el intervalo de tiempo que ha transcurrido desde
  205.         // que se ha arrancado el Timer
  206.         segundos = calculaLapso( new Date() );
  207.  
  208.         if( segundos >= duracion )
  209.             return( true );
  210.         else
  211.             return( false );
  212.         }
  213.          
  214.  
  215.     private int calculaLapso( Date actual ) {
  216.         Date dfinal;
  217.         int  segundos = 0;
  218.  
  219.         if( enEjecucion )
  220.             dfinal = actual;
  221.         else
  222.             dfinal = parada;
  223.  
  224.         // Si se quiere mas precision, en vez de Date(), se puede
  225.         // utilizar System.currentTimeMillis(), que proporciona
  226.         // muchisima mas resolucion
  227.         segundos += ( dfinal.getHours() - inicio.getHours() ) * 3600;
  228.         segundos += ( dfinal.getMinutes() - inicio.getMinutes() ) * 60;
  229.         segundos += ( dfinal.getSeconds() - inicio.getSeconds() );
  230.         return( segundos );
  231.         }
  232.    
  233.  
  234.     // Aqui implementamos la espera. El lapso en milisegundos se lo
  235.     // pasamos al metodo wait() del thread
  236.     // Este metodo es sincronizado porque sino salta una excepcion
  237.     // interna en el interprete de Java. No esta muy bien documentado
  238.     // el porque, pero parece ser que no se puede llamar al metodo
  239.     // wait() de un thread desde otro que no sea sincronizado
  240.     private synchronized void esperar( int lapso )
  241.         throws InterruptedException {
  242.         this.wait( lapso );
  243.         }  
  244.     }
  245.    
  246. //--------------------------------------------- Final del fichero Timer.java
  247.    
  248.  
  249.  

Código: Text
  1. //  
  2. //  Temporizador.java
  3. //  Copyright (c) 1996, Agustin Froufe
  4. //  Todos los derechos reservados.
  5. //  
  6. //  No se asume ninguna  responsabilidad por el  uso o  alteracion  de este
  7. //  software.  Este software se proporciona COMO ES, sin garantia de ningun
  8. //  tipo de su funcionamiento y en ningun caso sera el autor responsable de
  9. //  daños o perjuicios que se deriven del mal uso del software,  aun cuando
  10. //  este haya sido notificado de la posibilidad de dicho daño.
  11. //
  12. //   Compilador: javac 1.0
  13. //        Autor: Agustin Froufe
  14. //     Creacion: 23-Oct-1996  13:56:30
  15. //
  16. //--------------------------------------------------------------------------
  17. //  Esta informacion no es necesariamente definitiva y esta sujeta a cambios
  18. //  que pueden ser incorporados en cualquier momento, sin avisar.
  19. //--------------------------------------------------------------------------
  20.  
  21.  
  22. //
  23. // Interface que vamos a utilizar en la implementacion del timer, con el
  24. // que luego generaremos el reloj digital de demostracion
  25. // Esta interface debe ser implementada por cualquier clase que desee
  26. // ser informada de los eventos que genere el Timer, en nuetro caso el
  27. // reloj
  28. //
  29. public interface Temporizador {
  30.     public void timerArrancado( Timer timer );  
  31.     public void timerParado( Timer timer );  
  32.     public void timerMuerto( Timer timer );
  33.     public void timerIntervalo( Timer timer );
  34.     }
  35.  
  36. //------------------------------------- Final del fichero Temporizador.java
  37.  
  38.  

La idea general es que cuando pase cierto tiempo otro programa(temporizador) (trhead  == hilo ) le envie una señal al
programa principal (donde se estan leyendo los datos ) para que prosiga la ejecucion del mismo y que procese lo que se leyo del socket.
OK

 :alien:

m0skit0

  • Miembro de PLATA
  • *****
  • Mensajes: 2337
  • Nacionalidad: ma
    • Ver Perfil
    • http://fr33kk0mpu73r.blogspot.com/
Re: Duda con BufferedReader
« Respuesta #2 en: Sábado 17 de Enero de 2009, 17:03 »
0
Cita de: "ropel"
¿cómo puedo hacer para que mire si se han enviado datos por ese socket y, en caso positivo procesarlos y en caso negativo no permanecer a la espera, sino que me continúe con el programa?
Tengo una duda con tu problema: ¿debe esperar tiempo a por los datos? ¿cuánto tiempo debe estar esperando? ¿o debe seguir y cuando se introduzcan los datos capturarlos, sea cual sea el momento?

ropel

  • Miembro activo
  • **
  • Mensajes: 32
    • Ver Perfil
Re: Duda con BufferedReader
« Respuesta #3 en: Lunes 19 de Enero de 2009, 18:14 »
0
Hola a todos,

Gracias a los dos por contestar mi pregunta. Os comento un poco más y a ver si os puedo resolver las dudas que tenéis.

Yo en principio, no quiero que el programa espere para la recepción de datos, es decir, solamente quiero comprobar en un instante determinado de tiempo si se han enviado datos en un socket. Si la comprobación resulta que no se han recibido datos en el socket correspondiente, el programa siga, pero actualmente, tal y como lo tengo implementado, se queda bloqueado en la llamada a:

Código: Text
  1. reader.readLine();
  2.  

Mi idea es que compruebe si tengo datos en el socket. Si es así, los recogo, en caso contrario, sigo con el programa. ¿Me entendéis ahora mejor? Espero haberme explicado ahora mejor que en el post anterior.

¿Alguna idea o solución? De todas maneras, muchas gracias de antemano.

m0skit0

  • Miembro de PLATA
  • *****
  • Mensajes: 2337
  • Nacionalidad: ma
    • Ver Perfil
    • http://fr33kk0mpu73r.blogspot.com/
Re: Duda con BufferedReader
« Respuesta #4 en: Martes 20 de Enero de 2009, 10:39 »
0
¿El BufferedReader no te oferece ningún método para comprobar si hay datos, sin leerlos?

silverfox

  • Miembro MUY activo
  • ***
  • Mensajes: 280
    • Ver Perfil
Re: Duda con BufferedReader
« Respuesta #5 en: Martes 20 de Enero de 2009, 14:59 »
0
Hola...

Echa un vistazo al paquete java.nio

Los canales (Channel) permiten hacer lectura no bloqueante del stream de datos. Convierte la entrada de teclado en un Channel y utiliza la lectura en modo nonblocking.

Espero que te sirva.


Un saludo.


Silverfox