---

MainReadWriteLock.java

public class MainReadWriteLock {
    public static void main(String[] args) {
        ReadWriteLock rw = new WriterPreferenceReadWriteLock();
        new ReaderThread(rw).start();
        new WriterThread(rw).start();
        new WriterThread(rw).start();
    }
}
class ReaderThread extends Thread {
    Reader r;
    public ReaderThread(ReadWriteLock rw) {
        r = new Reader(rw);
    }
    public void run() {
        while (true) {
            try {
                r.read();
            } catch (InterruptedException e) {
            }
        }
    }
}
class Reader {
    ReadWriteLock rw;
    public Reader(ReadWriteLock rw) {
        this.rw = rw;
    }
    public void read() throws InterruptedException {
        rw.readLock().acquire();
        System.out.println("Start reading...");
        System.out.println("Finish reading...");
        rw.readLock().release();
    }
}
class WriterThread extends Thread {
    Writer w;
    public WriterThread(ReadWriteLock rw) {
        w = new Writer(rw);
    }
    public void run() {
        while (true) {
            try {
                w.write();
            } catch (InterruptedException e) {
            }
        }
    }
}
class Writer {
    ReadWriteLock rw;
    public Writer(ReadWriteLock rw) {
        this.rw = rw;
    }
    public void write() throws InterruptedException {
        rw.writeLock().acquire();
        System.out.println("Start writing...");
        System.out.println("Finish writing...");
        rw.writeLock().release();
    }
}
interface Sync {
    public void acquire() throws InterruptedException;
    public boolean attempt(int msecs) throws InterruptedException;
    public void release();
}
interface ReadWriteLock {
    Sync readLock();
    Sync writeLock();
}
abstract class Signaller {
    abstract void signalWaiters();
}
/**
 * @observable
 *   EXP notEqual (ReaderLock rl1, ReaderLock rl2): rl1 != rl2;
 */
class ReaderLock extends Signaller implements Sync {
    WriterPreferenceReadWriteLock wprw;
    public ReaderLock(WriterPreferenceReadWriteLock wprw) {
        this.wprw = wprw;
    }
    /**
      * @observable
      *   RETURN successfully(this);
      */
    public void acquire() throws InterruptedException {
        Object ie = null;
        synchronized (this) {
            if (!wprw.startReadFromNewReader()) {
                for (;;) {
                    try {
                        wait();
                        if (wprw.startReadFromWaitingReader())
                            return;
                    } catch (InterruptedException ex) {
                        wprw.cancelledWaitingReader();
                        ie = ex;
                        break;
                    }
                }
            }
        }
        if (ie != null) {
            wprw.writerLock_.signalWaiters();
            throw (Throwable) ie;
        }
    }
    public boolean attempt(int msecs) throws InterruptedException {
        Object ie = null;
        synchronized (this) {
            if (msecs <= 0)
                return wprw.startRead();
            else
                if (wprw.startReadFromNewReader())
                    return true;
                else {
                    int waitTime = msecs;
                    int start = System.currentTimeMillis();
                    for (;;) {
                        try {
                            wait(waitTime);
                        } catch (InterruptedException ex) {
                            wprw.cancelledWaitingReader();
                            ie = ex;
                            break;
                        }
                        if (wprw.startReadFromWaitingReader())
                            return true;
                        else {
                            waitTime = msecs - (System.currentTimeMillis() - start);
                            if (waitTime <= 0) {
                                wprw.cancelledWaitingReader();
                                break;
                            }
                        }
                    }
                }
        }
        wprw.writerLock_.signalWaiters();
        if (ie != null)
            throw (Throwable) ie;
        else
            return false;
    }
    public void release() {
        Signaller s = wprw.endRead();
        if (s != null)
            s.signalWaiters();
    }
    synchronized void signalWaiters() {
        notifyAll();
    }
}
/**
 * @observable
 *   EXP notEqual (WriterLock wl1, WriterLock wl2): wl1 != wl2;
 */
class WriterLock extends Signaller implements Sync {
    WriterPreferenceReadWriteLock wprw;
    public WriterLock(WriterPreferenceReadWriteLock wprw) {
        this.wprw = wprw;
    }
    /**
      * @observable
      *   RETURN successfully(this);
      */
    public void acquire() throws InterruptedException {
        Object ie = null;
        synchronized (this) {
            if (!wprw.startWriteFromNewWriter()) {
                for (;;) {
                    try {
                        wait();
                        if (wprw.startWriteFromWaitingWriter())
                            return;
                    } catch (InterruptedException ex) {
                        wprw.cancelledWaitingWriter();
                        notify();
                        ie = ex;
                        break;
                    }
                }
            }
        }
        if (ie != null) {
            wprw.readerLock_.signalWaiters();
            throw (Throwable) ie;
        }
    }
    public boolean attempt(int msecs) throws InterruptedException {
        Object ie = null;
        synchronized (this) {
            if (msecs <= 0)
                return wprw.startWrite();
            else
                if (wprw.startWriteFromNewWriter())
                    return true;
                else {
                    int waitTime = msecs;
                    int start = System.currentTimeMillis();
                    for (;;) {
                        try {
                            wait(waitTime);
                        } catch (InterruptedException ex) {
                            wprw.cancelledWaitingWriter();
                            notify();
                            ie = ex;
                            break;
                        }
                        if (wprw.startWriteFromWaitingWriter())
                            return true;
                        else {
                            waitTime = msecs - (System.currentTimeMillis() - start);
                            if (waitTime <= 0) {
                                wprw.cancelledWaitingWriter();
                                notify();
                                break;
                            }
                        }
                    }
                }
        }
        wprw.readerLock_.signalWaiters();
        if (ie != null)
            throw (Throwable) ie;
        else
            return false;
    }
    public void release() {
        Signaller s = wprw.endWrite();
        if (s != null)
            s.signalWaiters();
    }
    synchronized void signalWaiters() {
        notify();
    }
}

class WriterPreferenceReadWriteLock implements ReadWriteLock {
    protected int activeReaders_ = 0;
  protected int activeWriter_ = 0;
    protected int waitingReaders_ = 0;
    protected int waitingWriters_ = 0;
    protected final ReaderLock readerLock_ = new ReaderLock(this);
    protected final WriterLock writerLock_ = new WriterLock(this);
    protected boolean allowReader() {
        return activeWriter_ == 0 && waitingWriters_ == 0;
    }
    protected synchronized void cancelledWaitingReader() {
        --waitingReaders_;
    }
    protected synchronized void cancelledWaitingWriter() {
        --waitingWriters_;
    }
    protected synchronized Signaller endRead() {
        if (--activeReaders_ == 0 && waitingWriters_ > 0)
            return writerLock_;
        else
            return null;
    }
    protected synchronized Signaller endWrite() {
        activeWriter_ = 0;
        if (waitingReaders_ > 0 && allowReader())
            return readerLock_;
        else
            if (waitingWriters_ > 0)
                return writerLock_;
            else
                return null;
    }
    public Sync readLock() {
        return readerLock_;
    }
    protected synchronized boolean startRead() {
        boolean allowRead = allowReader();
        if (allowRead)
            ++activeReaders_;
        return allowRead;
    }
    protected synchronized boolean startReadFromNewReader() {
        boolean pass = startRead();
        if (!pass)
            ++waitingReaders_;
        return pass;
    }
    protected synchronized boolean startReadFromWaitingReader() {
        boolean pass = startRead();
        if (pass)
            --waitingReaders_;
        return pass;
    }
    protected synchronized boolean startWrite() {
        boolean allowWrite = (activeWriter_ == 0 && activeReaders_ == 0);
        if (allowWrite)
            activeWriter_ = 1;
        return allowWrite;
    }
    protected synchronized boolean startWriteFromNewWriter() {
        boolean pass = startWrite();
        if (!pass)
            ++waitingWriters_;
        return pass;
    }
    protected synchronized boolean startWriteFromWaitingWriter() {
        boolean pass = startWrite();
        if (pass)
            --waitingWriters_;
        return pass;
    }
    public Sync writeLock() {
        return writerLock_;
    }
}

---