Java: seguro de subproceso RandomAccessFile

Question

Después de un poco de googlear encontré que la clase RandomAccessFile no es segura para subprocesos. Ahora podría usar un semáforo para bloquear todas las lecturas y escrituras, pero no creo que funcione muy bien. En teoría, debería ser posible hacer múltiples lecturas y una escritura a la vez. ¿Cómo puedo hacer esto en Java? ¿Es posible?

Gracias!

Answer 1

El bloqueo parcial de un archivo es un negocio complejo que muchos sistemas operativos evitan. Sin embargo, si insiste en hacerlo, una forma es diseñar su propio objeto de mecanismo de bloqueo que registre qué partes del archivo están bloqueadas. Esencialmente, antes de leer o escribir un objeto, debe solicitar un bloqueo para un rango de bytes específico del archivo. Se considera que las cerraduras chocan si se superponen en absoluto en el rango de bytes. Los bloqueos de lectura y escritura se tratan de manera diferente: una lectura puede superponerse con cualquier cantidad de bloqueos de lectura de forma segura, pero un bloqueo de escritura debe superponerse sin otros bloqueos, leer o escribir. Hay muchas preguntas sobre si esperar o cancelar si no puede obtener el bloqueo y si se bloquean las lecturas mientras espera una escritura, pero solo usted puede responderlas sobre su aplicación.

Dada la complejidad de esto, puede ser mejor bloquear el archivo completo. Compruebe si obtiene un rendimiento adecuado, y no olvide que puede permitir varias lecturas a la vez, siempre que no haya escrituras.

Answer 2

que podría utilizar un semáforo para bloquear todos de lectura y escritura, pero no creo que funciona muy bien.

Con respecto al rendimiento, NUNCA piense. SIEMPRE mide

Dicho esto, java.util.concurrent.locks.ReentrantReadWriteLock es lo que estás buscando.

Answer 3

Considere este enfoque: permite lectores ilimitados, y cuando un escritor desea escribir, espera que los lectores actuales terminen de escribir.

class readWriteSemaphore() { 
    private Object lock; 
    List<Thread> readers; 
    Thread writer; 

    readWriteSemaphore() { 
     readers = new LinkedList<Thread>(); // Linked list is inefficient for many threads, FYI 
     writer = null; 
    } 

    /** 
    * Returns true if and only if you have acquired a read 
    * maybe use while(!rws.acquireRead(Thread.currentThread())) Thread.sleep(50); // or something 
    */ 
    boolean acquireRead(Thread t) { 
     synchronized(lock) { 
      if(writer == null) { 
       readers.add(t); 
       return true; 
      } 
      return false; // yes this could go outside the synch block... oh well 
     } 
    } 

    void releaseRead(Thread t) { 
     synchronized(lock) { 
      while(readers.remove(t)); // remove this thread completely 
     } 
    } 

    boolean acquireWrite(Thread t) { 
     synchronized(lock) { 
      if(writer == null) return false; 
      writer = t; 
     } 
     while(readers.size() > 0) Thread.sleep(50); // give readers time to finish. 
     //They can't re-enter yet because we set the writer, 
     // if you attempt to acquire a write, future reads will be false until you're done 
     return true; 
    } 

    void releaseWrite(Thread t) { 
     synchronized(lock) { 
      if(t != writer) throw new IllegalArgumentException("Only writer can release itself"); 
      writer = null; 
     } 
    } 

} 

Answer 4

Si un mutex simple en todo el archivo se va a dar un cuello de botella, y RandomAccessFile no es seguro para subprocesos y sin un mutex, entonces usted necesita para buscar alternativas a RandomAccessFile.

Una alternativa es asignar el archivo a la memoria como MappedBuffer y usar sectores del buffer para permitir que diferentes hilos accedan al archivo sin interferir entre ellos. El bloqueo de un solo escritor/lector múltiple en la granularidad del conjunto sería fácil de implementar. También podría ir más allá e implementar la lectura y escritura concurrentes de secciones del archivo que no se superpongan, pero eso sería más complicado.

No me sorprendería escuchar que alguien, en algún lugar ya ha implementado esto como una biblioteca reutilizable.