DOMANDA [JAVA] Problema lettore scrittore e synchronized

[GHoldenBoy]

Ho sviluppato una classe di lock chiamata "GestoreAccessi" per permettere l'accesso sincronizzato a diversi file da parte di thread in lettura o in scrittura (il classico problema lettore/scrittore risolto con i lock).
Io cercavo una modalità per la quale fosse possibile che più thread potessero accedere contemporaneamente in lettura mentre la scrittura fosse possibile solo per un thread alla volta.

Per risolvere il mio problema ho creato questa classe:

import java.io.Serializable; 
public class GestoreAccessi implements Serializable{
     private int lettori= 0;
     private boolean scrittura= false;
     private int scrittoriAttesa = 0;
     private String nome;
      //Il gestore accessi prende un nome
     public GestoreAccessi(String nom) {
         nome = nom;
     }
     //Blocco per la lettura
     public synchronized void lockRead() {
         try {
             //Fino a che c'e' qualcuno in scrittura o processi che aspettano per la scrittura mi metto in attesa
             while (scrittura || scrittoriAttesa > 0) {
                 wait();
             }
             //Altrimenti aumento la variabile dei thread in lettura
             ++lettori;
         } catch (InterruptedException ex) {
         }
     }     
//Fine del processo di lettura     
public synchronized void unlockRead() {
         --lettori;
         // solo gli scrittori sono in attesa e uno soltanto deve essere svegliato
         if (lettori == 0) {
             notifyAll();
         }
     }
     //Blocco per la scrittura
     public synchronized void lockWrite() {
         ++scrittoriAttesa;
         //Fino a che ci sono lettori o qualcuno che scrive aspetto
         while (lettori > 0 || scrittura) {
             try {
                 wait();
             } catch (InterruptedException ex) {
             }
         }
         --scrittoriAttesa;
         //Altrimenti inizio il processo di lettura
         scrittura = true;
     }
     //Fine del processo di scrittura
     public synchronized void unlockWrite() { 
        scrittura = false;
         notifyAll(); // sblocca uno o piu' lettori o uno scrittore
     }
 }

Nei punti critici del codice, in base a se si dovesse leggere o scrivere sulla risorsa condivisa, ho creato degli oggetti GestoreAccessi che invocassero i metodi .lock e .unlock ...
Secondo voi questa soluzione è corretta?

Io ho qualche dubbio per quanto riguarda il garantire la lettura multipla; leggendo ora le specifiche della clausola "synchronized" notavo:

First, it is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object.
Second, when a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads.

quindi non capisco: sarà possibile per due thread leggere contemporaneamente? dato che il metodo .lockread() è dichiarato synchronized una volta che un THread ha avuto accesso alla porzione di codice bloccata da quel lock non sarà possibile che un altro thread esegua la stessa parte di codice?! Come avrebbe dovuto essere la soluzione, semplicemente non va dichiarata synchronized la parte della lettura??

Vi prego datemi qualche dritta su sta storia che proprio non riesco a capire come funziona!!