Java: Thread-Safe RandomAccessfile

Le verrouillage partiel d'un fichier est une entreprise complexe qui, beaucoup de systèmes d'exploitation, évitez de faire. Toutefois, si vous insistez sur le faire, une solution est de concevoir votre propre objet de mécanisme de verrouillage qui enregistre les parties du fichier sont verrouillées. Essentiellement avant de lire ou d'écrire un objet doit demander une serrure pour une plage d'octets spécifique du fichier. Les verrous sont considérés comme des affrontements s'ils se chevauchent du tout dans la plage d'octets. Les serrures de lecture et d'écriture sont traitées différemment: une lecture peut se chevaucher avec n'importe quel nombre de serrures de lecture en toute sécurité, mais une serrure d'écriture doit se chevaucher sans autre serrure, lire ou écrire. Il y a beaucoup de questions sur l'attente ou l'abandon si vous ne pouvez pas obtenir le verrou, et s'il faut bloquer les lectures pendant qu'une écriture attend, mais seulement vous pouvez y répondre de votre application.

Compte tenu de la complexité de celle-ci, il peut être préférable de verrouiller le fichier entier. Vérifiez si vous obtenez des performances adéquates - et n'oubliez pas que vous pouvez autoriser plusieurs lectures à la fois, tant qu'il n'y a pas d'écriture.

Considérez cette approche - il permet aux lecteurs illimités et lorsqu'un écrivain veut écrire, il attend que les lecteurs actuels se terminent pour faire son écriture.

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;
        }
    }

}

Si un simple mutex sur l'ensemble du fichier va vous donner un goulot d'étranglement de la performance et randomAccessfile n'est pas thread-coffre-fort sans mutex, alors vous devez regarder des alternatives à RandomAccessFile .

Une alternative consiste à mapper le fichier en mémoire sous forme de mappé et d'utiliser des tranches du tampon pour permettre à différents threads d'accéder au fichier sans interférer les uns avec les autres. L'écrivain unique / le verrouillage de plusieurs lecteurs multiples à la granularité de l'ensemble serait facile à mettre en œuvre. Vous pouvez également aller plus loin et mettre en œuvre une lecture et une écriture simultanées de sections non chevauchantes du fichier, mais cela serait plus compliqué.

Je ne serais pas surpris d'entendre que quelqu'un, quelque part a déjà mis en œuvre cela comme une bibliothèque réutilisable.