import java.util.*;

public class ReaderWriterLock implements IReaderWriterLock {
    volatile int num_activeReader = 0;
    volatile int num_activeWriter = 0;
    volatile int num_waitingReader = 0;
    volatile int num_waitingWriter = 0;
    HashSet<Thread> currentlyReading = new HashSet<Thread>();
    Thread currentlyWriting =new Thread();
    Object _lock = new Object();
  
    public void startRead(){
        if (currentlyReading.contains(Thread.currentThread())) {
            return;
        }
        if (currentlyWriting==Thread.currentThread()) {
            throw new DeadlockException();
        }
        synchronized(_lock) {
            num_waitingReader++;
            while(num_waitingWriter != 0 || num_activeWriter != 0){
                try {
                    _lock.wait();
                }
                catch(InterruptedException ie) { /* ignore */ }
        
            }
            num_waitingReader--;
            num_activeReader++;
            currentlyReading.add(Thread.currentThread());
        }
    }
  
    public void endRead(){
        if (!currentlyReading.contains(Thread.currentThread())) {
            return;
        }
        synchronized(_lock) {
            num_activeReader--;
            currentlyReading.remove(Thread.currentThread());
            if(num_activeReader==0)
                _lock.notifyAll();
        }      
    }
  
    public void startWrite(){
        if (currentlyReading.contains(Thread.currentThread())||currentlyWriting==Thread.currentThread()) {
            throw new DeadlockException();
        }
        synchronized(_lock) {
            num_waitingWriter++;
            while(num_activeWriter != 0 || num_activeReader != 0){
                try {
                    _lock.wait();
                }
                catch(InterruptedException ie) { /* ignore */ }
        
            }
            num_waitingWriter--;
            num_activeWriter++;
            currentlyWriting=Thread.currentThread();
        }
    }
  
  
    public void endWrite(){
        synchronized(_lock) {
            num_activeWriter--;
            currentlyWriting=new Thread();
            _lock.notifyAll();
        }      
    }  
}