ReadWriteLock.java

import java.util.concurrent.Semaphore;

public class ReadWriteLock {

    // resource lock (rw_mutex)
    private final Semaphore S = new Semaphore(1);

    private final Semaphore mutex = new Semaphore(1);

    // turnstile to prevent writer starvation
    private final Semaphore serviceQueue = new Semaphore(1, true);

    private int readCount = 0;

    // Reader entry
    public void readLock() {
        boolean gotQueue = false;
        boolean gotMutex = false;

        try {
            serviceQueue.acquire();
            gotQueue = true;

            mutex.acquire();
            gotMutex = true;

            readCount++;
            if (readCount == 1) {
                                        // first reader locks resource; if interrupted here readCount will always be 1 so roll back  ( if interrupted right here, no deadlock  )
                try {
                    S.acquire();
                } catch (InterruptedException e) {
                    readCount--; // rollback  
                    throw e;
                }
            }

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("readLock interrupted", e);

        } finally {
            if (gotMutex) mutex.release();
            if (gotQueue) serviceQueue.release();
        }
    }

    // Reader exit
    public void readUnLock() {
        boolean gotMutex = false;

        try {
            mutex.acquire();
            gotMutex = true;

            readCount--;
            if (readCount == 0) {
                                  // last reader will release the resource
                S.release();
            }

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("readUnlock interrupted", e);

        } finally {
            if (gotMutex) mutex.release();
        }
    }

    // Writer entry
    public void writeLock() {
        boolean gotQueue = false;

        try {
            serviceQueue.acquire();
            gotQueue = true;
                                    // once writer is at the front of the queue, it waits for the resource
            S.acquire();

        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("writeLock interrupted", e);

        } finally {
            // release the queue lock
            if (gotQueue) serviceQueue.release();
        }
    }

    // Writer exit
    public void writeUnLock() {
        S.release();
    }
}