Evitar bloqueo del metodo read() de un objeto Socket en java/j2me

Iniciado por cyber33, 3 Enero 2013, 05:24 AM

0 Miembros y 1 Visitante están viendo este tema.

cyber33

Hola a todos. Estoy tratando de buscar una forma de evitar el bloqueo que se produce al llamar al método read() cuando se usa un objeto SocketConnection (j2me) o Socket (java). Estoy usando j2me en este momento pero igual se extiende lo mismo usando java. Por el momento el metodo available() no me sirve de mucho ya que en su mayoria devuelve cero. Esto era una buena alternativa para leer cuantos datos hay disponibles y asi evitar el bloqueo pero la descarto. Por otra parte esta el método read(byte[],position,length). Es casi lo mismo que read() pero se leen varios bytes en el array.

El siguiente codigo podria funcionar muy bien pero no se puede utilizar is.available(). Además este metodo proceso() esta ejecutandose dentro de un hilo.
Código (java) [Seleccionar]

  public void proceso(){
              try {
                  int d=is.available();
                  if(d!=0){
                      byte[] bytes=new byte[d];
                      int offset=0;
                      while(offset<bytes.length){
                          int value=is.read(bytes,offset, d);
                          if(value==-1)break;
                          offset+=value;
                      }
                      int i=0;
                      while(i<bytes.length){
                          System.out.print((char)bytes[i]);
                          i++;
                      }
                  }           
              } catch (IOException ex) {
              }
  }


Y el siguiente codigo que por cierto es ineficiente igual puede bloquearse en la linea is.read() segun lo que probe.

Código (java) [Seleccionar]

public void proceso1(){
        try {
            int d=is.read();
            while(d!=-1){
                System.out.println((char)d);
                d=is.read();       
            }
        } catch (IOException ex) {
            ex.printStackTrace();
        }
  }

Una forma mas eficiente de esto para leer que hize fue leer con el metodo read(byte[],position,length). Pero aún se bloquea.


Eh notado que si el procesamiento es mas lento se bloquee porque quizas no esten los datos rapidamente disponibles. En cambio si ya estan entonces no se bloquearia en la linea de is.read(). Solo es una observación. Nose como hacen realmente las aplicaciones de este tipo.

Espero que me puedan ayudar a buscar una forma para evitar este bloqueo.

Desde ya muchas gracias.

Saludos.[/color]

juancaa

Si lo que quieres es comprobar si tu objeto Socket o bien InputStream o OutputStream estan disponibles me temo que lo que deberias utilizar es synchronized.  Y por lo que respecta al boqueo tengo el mismo problema pero creo que se puede solucionar estableciendo un tiempo limite a la transmision, algo como en caso de que no recibas datos en 1000 ms entonces seguir ejeutando codigo pero esto no lo he probado...

Un ejemplo de synchronized de un codigo mio...

Código (java) [Seleccionar]
    public byte[] readBytes (Socket socket) {
        byte[] data = null;

        try {
            DataInputStream dis = new DataInputStream(socket.getConnection().getInputStream());
            synchronized (dis) {
                int len = dis.readInt();
                data = new byte[len];       
                if (len > 0) dis.readFully(data);           
            }
        } catch (IOException ex) { System.out.println("Error reading input bytes"); }
        return data;
    }


No se si es esto lo que buscabas exactamente, ya me diras... Un saludo y felices fiestas!
Que tengas un buen dia!

cyber33

#2
Hola felices fiestas, gracias por contestar. Estuve probando el codigo que escribiste y me sale una excepción "Exception in thread "Thread-0" java.lang.OutOfMemoryError: Java heap space". Porque cuando se lee en la linea int len=readInt() me devuelve un valor de 1010792557 y por consecuencia en data = new byte[len] es muy grande el valor. No habia utilizado el método readInt(). Suelo utilizar mas el read() que lee byte por byte. Aunque nose si lo entiendo bien al método readInt() que según dice la documentación lee de a cuatro bytes y es raro que me de un número de 1010792557. Por otra parte estuve probando sobre el bloqueo y llego a la conclusión que se va a bloquear siempre en el metodo read(). Solo recien cuando lleguen mas datos se va a desbloquear. Y esto es leyendo byte por byte. Lo que si nose muy bien es como leer de más de un byte ahi si se bloquea para siempre según lo que probe. Por ejemplo si creo un array de byte de 1024 de capacidad y luego utilizo el metodo read(byte[] b) entonces si solo hay 500 datos disponibles en el flujo entonces se bloqueara ahi y no podra avanzar más. Solo pense que puede ser porque todavia no logro llenar los 1024 bytes de capacidad del array. Probe enviar mas datos para ver si se llena pero aun quedo bloqueado. Solo si es justa la cantidad entonces no se va a bloquear. En otras palabras habria que saber la cantidad de bytes que hay y eso seria utilizando available() pero ya lo tengo descartado.


Saludos.

juancaa

Fijate en que al aplicar el metodo readInt() lo que hago es leer un numero entero. Aqui te dejo la parte del codigo del servidor para que se envien los bytes:

Código (java) [Seleccionar]
    public void sendBytes (byte[] bytes) {
        try {           
            synchronized (dos) {
                int start = 0, len = bytes.length;
                if (len < 0) {
                    throw new IllegalArgumentException("Negative length not allowed");
                } if (start < 0 || start >= bytes.length) {
                    throw new IndexOutOfBoundsException("Out of bounds: " + start);
                }
                dos.writeInt(len);
                if (len > 0) { dos.write(bytes, start, len); }                   
            }
        } catch (IOException ex) { System.out.println("Error sending bytes"); }
    }


Lo que hago es primero mandar el tamaño del array de bytes al cliente (numero entero), luego el cliente lee el tamaño del array y crea por tanto un array de ese tamaño (lineas 7 y 8 codigo 1) luego el servidor manda todo el array de bytes para que el cliente pueda leerlo mediante el metodo readFully(). El error que tu me comentabas se debe a que supongo no entendiste el funcionamiento del codigo que te puse y le mandaste directamente los bytes sin especificar antes el tamaño. Espero que ahora si lo hayas entendido  ;)
Que tengas un buen dia!