Java multithreading lock is not working correctly

The whole program is :

import java.util.concurrent.*;
import java.util.concurrent.locks.*;
public class AccountWithConditionsUser {
private static Account account = new Account();
public static void main(String[] args) {
System.out.println("Thread 1\t\tThread 2\t\tBalance");
ExecutorService executor = Executors.newFixedThreadPool(2);
executor.execute(new DepositTask());
executor.execute(new WithdrawTask());
executor.shutdown();
while(!executor.isShutdown()) {
}
}
public static class DepositTask implements Runnable{
public void run() {
try {
while(true) {
account.deposit((int)(Math.random()* 10)+ 1);
Thread.sleep(1000);
}
}
catch(InterruptedException ex) {
ex.printStackTrace();
}
}
}
public static class WithdrawTask implements Runnable{
public void run() {
while(true) {
account.withdraw((int)(Math.random() * 10) + 1);
}
}
}
private static class Account{
private static Lock lock = new ReentrantLock(true);
private static Condition newDeposit = lock.newCondition();
private int balance = 0;
public int getBalance() {
return balance;
}
public void withdraw(int amount) {
lock.lock();
System.out.println("->Withdraw Obtained Lock");
try {
while(balance < amount) {
System.out.println("\t\t\tWait for deposit");
newDeposit.await();
}
balance-=amount;
System.out.println("\t\t\tWithdraw "+ amount + "\t\t" + getBalance());
}
catch(Exception e) {
e.printStackTrace();
}
finally {
System.out.println("->Withdraw Released Lock");
lock.unlock();
}
}
public void deposit(int amount) {
lock.lock();
System.out.println("->Deposit Obtained Lock");
try {
balance+=amount;
System.out.println("Deposit "+ amount + "\t\t\t\t\t" + getBalance());
newDeposit.signalAll();
}
catch(Exception e) {
e.printStackTrace();
}
finally {
System.out.println("->Deposit Released Lock");
lock.unlock();
}
}
}
}

And the sample part of the output I got for this code is:

......

......

Withdraw Released Lock

Withdraw Obtained Lock

Wait for deposit

Deposit Obtained Lock

Deposit 9 13

Deposit Released Lock

Withdraw 9 4

Withdraw Released Lock

.....

.....

The question here is how Deposit thread obtained lock after window obtained lock. Isn't it supposed to be that once a lock is obtained it can't be obtained by any other thread! Or is it because of the signal methods? Can anyone please explain how that output came?
Thanks in advance

After Withdraw obtains the lock it checks if there is sufficient balance. If there is not, then it calls newdeposit.await, which will release the lock so other threads waiting on the same lock can get in. That appears to be what happened: Withdraw entered into that if-block, started waiting, the Deposit thread came in and deposited an amount and woke Withdraw up, so it can continue with the updated amount. Once a notification is received, await locks and returns, so Withdraw continues execution with lock acquired.