Java 多线程锁不能正常工作

Question

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 :)

Answer 1

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.