public synchronized  void acquire() throws InterruptedException 
{
                                                 
        while (tryToAcquire() == false)
        {
            wait();
        }
}

Acquire the mutex. The mutex can be acquired multiple times by the same thread, provided that it is released as many times as it is acquired. The calling thread blocks until it has acquired the mutex. (There is no timeout).

 public synchronized  void release() 
{
        if (owner != Thread.currentThread())
            throw new IllegalStateException("Thread calling release() doesn't own mutex");
        if (--lock_count < = 0)
        {
            owner = null;
            notify();
        }
}

Release the mutex. The mutex has to be released as many times as it was acquired to actually unlock the resource. The mutex must be released by the thread that acquired it

 public synchronized boolean tryToAcquire() 
{
        // Try to get the mutex. Return true if you got it.
        if( owner == null )
        {
            owner = Thread.currentThread();
            lock_count = 1;
            return true;
        }
        if( owner == Thread.currentThread() )
        {
            ++lock_count;
            return true;
        }
        return false;
}

Attempts to acquire the mutex. Returns false (and does not block) if it can't get it.