Java Lock Condition Wait and Notify: IllegalMonitorStateException

Question

I am new to Java. I just read the "core java" book. I met a issue about 'Condition & Lock'.

I typed a piece of code from the book to the eclipse to do some practice.

When I run the code ,the line of "sufficientFund.wait();" throws an IllegalMonitorStateException. Why here has an exception?

I hava googled for a while, I know that "This method should only be called by a thread that is the owner of this object's monitor." I think the current thread has the lock, because the 'bankLock.lock();' is executed just before wait(). I think the correct behavior of the code is, the current thread should be hung at the sufficientFund.wait(), but it didn't.

package com.first.java;

import java.util.Scanner;
import java.util.concurrent.locks.*;

public class BankTranf {

    private static final int NACCOUNT = 3;
    public static final double INITAL_BALANCE = 1000;

    public static void main(String[] args) {

        Bank bank = new Bank(NACCOUNT, INITAL_BALANCE);

        for (int i = 0; i < NACCOUNT; i++) {

            TransferRunnable transferRunnable = new TransferRunnable(bank, i, INITAL_BALANCE);

            Thread thread = new Thread(transferRunnable);
            thread.start();
        }

        System.out.println("press any key to exit.");
        Scanner in = new Scanner(System.in);
        in.nextLine();
        System.exit(0);
    }

}

class Bank {
    private final double[] account;
    private Lock bankLock;
    private Condition sufficientFund;

    public Bank(int n, double initialBanlance) {
        account = new double[n];
        for (int i = 0; i < account.length; i++) {
            account[i] = initialBanlance;
        }

        bankLock = new ReentrantLock();
        sufficientFund = bankLock.newCondition();

    }

    public void transfer(int from, int to, double amount) {
        bankLock.lock();

        try {
            while (account[from] < amount) {
                System.out.println(Thread.currentThread().getName() + " does'nt hava enough money");
                sufficientFund.wait();
            }

            System.out.println(Thread.currentThread());

            account[from] -= amount;
            System.out.printf("%10.2f from %d to %d ", amount, from, to);
            account[to] += amount;
            System.out.printf(" Total balance: %10.2f%n", getTotalBalance());
            sufficientFund.signalAll();

        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            bankLock.unlock();
        }
    }

    public double getTotalBalance() {
        double d = 0;
        bankLock.lock();
        try {
            for (double n : account) {
                d += n;
            }
            return d;
        } finally {
            bankLock.unlock();
        }
    }

    public int size() {
        return account.length;
    }

}

class TransferRunnable implements Runnable {

    private Bank bank;
    private int fromAccount;
    private double maxAmount;
    private int DELAY = 10;

    public TransferRunnable(Bank b, int from, double max) {
        bank = b;
        this.fromAccount = from;
        this.maxAmount = max;
    }

    @Override
    public void run() {

        try {
            while (true) {
                int toAcount = (int) (bank.size() * Math.random());
                double amount = maxAmount * Math.random();
                bank.transfer(fromAccount, toAcount, amount);
                Thread.sleep(4000/* (int)(DELAY*Math.random()) */);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

I also tried another way, I remove all the Lock and Condition, instead of using "synchronized", the code was running as I expected.

public synchronized void transfer(int from, int to, double amount) {
        //bankLock.lock();

        try {
            while (account[from] < amount) {
                System.out.println(Thread.currentThread().getName() + " does'nt hava enough money");

                wait();
            }

            System.out.println(Thread.currentThread());

            account[from] -= amount;
            System.out.printf("%10.2f from %d to %d ", amount, from, to);
            account[to] += amount;
            System.out.printf(" Total balance: %10.2f%n", getTotalBalance());

            notifyAll();

        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {

        }
    }

    public synchronized double getTotalBalance() {
        double d = 0;

        try {
            for (double n : account) {
                d += n;
            }
            return d;
        } finally {

        }
    }

Answer 1

Note that Condition as any class in Java extends Object and hence it has the wait method inherited from Object, which I believe you calling by mistake here, the method that your meant to be calling to wait on a condition is Condition#await rather than wait.