Readers Writers problem and Synchronized doubts

Question

I made this code for implementing some Lock because I have to permit the write/read action on shared file between different threads. I would like to let more than one thread reading at the same time and just one for the writing
This is my code, it's in italian but in english the class name would be AccessManager
import java.io.Serializable;
public class GestoreAccessi implements Serializable{
//number of reader
private int lettori= 0;
//flag for someone writing
private boolean scrittura= false;
//number of writer waiting
private int scrittoriAttesa = 0;
private String nome;
//Il gestore accessi prende un nome
public GestoreAccessi(String nom) {
nome = nom;
//Blocco per la lettura -- Lock for Reading
public synchronized void lockRead() {
try {
//Fino a che c'e' qualcuno in scrittura o processi che aspettano per la scrittura mi metto in attesa -- If ther is some thread writing or waiting for write
while (scrittura || scrittoriAttesa > 0) {
wait();
//Altrimenti aumento la variabile dei thread in lettura -- Add one thread reading
++lettori;
} catch (InterruptedException ex) {
//Fine del processo di lettura -- Finish reading
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 -- Start Writing
public synchronized void lockWrite() {
++scrittoriAttesa;
//Fino a che ci sono lettori o qualcuno che scrive aspetto -- if there are readers o someone writing
while (lettori > 0 || scrittura) {
try {
wait();
} catch (InterruptedException ex) {
--scrittoriAttesa;
//Altrimenti inizio il processo di lettura -- Start the process of reading
scrittura = true;
//Fine del processo di scrittura
public synchronized void unlockWrite() {
scrittura = false;
notifyAll(); // sblocca uno o piu' lettori o uno scrittore
Before all critical part I create a GestoreAccessi object and invoce the .lock.. method and finish the critical part the .unlock.. Do you think it's a good way to solve the problem?
I have some doubts on the multiple reading at the same time. I read on synchronized: "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."
It's possible to two different thread read at the same time? The .lockRead() method is synchronized: if one thread has acess in a critical part it takes the lock and no other thread would be able to have an access on the same part?! How can i do this? I have not to declare synchronized the read method?
Please help me and sorry for my bad english!!
Bless from Italy

Answer 1

>
I made this code for implementing some Lock because I have to permit the write/read action on shared file between different threads. I would like to let more than one thread reading at the same time and just one for the writing
>
Multiple threads and even applications can read the same file at the same time; it is writing that is problematic.
There is nothing in what you posted that even shows any 'file' manipulation so no comments can be made about that.
It looks like you took those quotes from this Java Tutorial Page on Synchronizeds Methods
http://docs.oracle.com/javase/tutorial/essential/concurrency/syncmeth.html
Those quotes are accurate as far as synchronizing a particular instance is concerned but that would not prevent some other code from trying to read/write the same file. But again, you code doesn't even include any file-related objects that you are trying to control access to.
See the Java Tutorial section on 'Lock Objects'
http://docs.oracle.com/javase/tutorial/essential/concurrency/newlocks.html