Synchronized methods

Compte bancaire
Compte bancaire dans le parcours Java 
class BankAccount {
    private int balance = 0;
    private boolean isClosed = true;

    synchronized void open() throws BankAccountActionInvalidException {
        if (!isClosed) {
            throw new BankAccountActionInvalidException("Account already open");
        }
        isClosed = false;
        balance = 0;
    }

    synchronized void close() throws BankAccountActionInvalidException {
        if (isClosed) {
            throw new BankAccountActionInvalidException("Account not open");
        }
        isClosed = true;
    }

    synchronized int getBalance() throws BankAccountActionInvalidException {
        checkIfClosed();
        return balance;
    }

    synchronized void deposit(int amount) throws BankAccountActionInvalidException {
        checkIfClosed();
        checkIfValidAmount(amount);

        balance += amount;
    }

    synchronized void withdraw(int amount) throws BankAccountActionInvalidException {
        checkIfClosed();
        checkIfValidAmount(amount);
        checkIfEnoughMoneyInAccount(amount);

        balance -= amount;
    }

    private void checkIfValidAmount(int amount) throws BankAccountActionInvalidException {
        if (amount < 0) {
            throw new BankAccountActionInvalidException("Cannot deposit or withdraw negative amount");
        }
    }

    private void checkIfEnoughMoneyInAccount(int amount) throws BankAccountActionInvalidException {
        if (balance == 0) {
            throw new BankAccountActionInvalidException("Cannot withdraw money from an empty account");
        }
        if (balance - amount < 0) {
            throw new BankAccountActionInvalidException("Cannot withdraw more money than is currently in the account");
        }
    }

    private void checkIfClosed() throws BankAccountActionInvalidException {
        if (isClosed) {
            throw new BankAccountActionInvalidException("Account closed");
        }
    }
}

Each operation method is marked synchronized. This tells the thread to acquire a lock on the BankAccount object before executing the method. If any other thread holds a lock on the BankAccount object, it must wait for the other thread to release the lock.

Note

In Java, the is one other way to acquire a lock on the BankAccount object - synchronized statements. Since synchronized methods use a lock on the BankAccount object, it will also have to wait for locks on the BankAccount that are used by synchronized statements to be reused.

The lock is automatically released when the method finishes.

23e Sep 2026 · Tu l'as trouvée utile ?

Autres approches pour l'exercice Compte bancaire dans le parcours Java

D'autres façons dont notre communauté a résolu cet exercice
private final Object lock = new Object();

void deposit(int amount) throws BankAccountActionInvalidException {
    synchronized(lock) {
        balance += amount;
    }
}
Synchronized statements

Use an object to prevent threads from running blocks of code at the same time 

private final ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    balance += amount;
} finally {
    lock.unlock();
}
Reentrant lock

Use an ReentrantLock to explicitly acquire and release locks 

private final ReadWriteLock lock = new ReentrantReadWriteLock();
lock.readLock().lock();
try {
        balance += amount;
} finally {
    lock.readLock().unlock();
}
Readwrite lock

Use separate read and write locks to achieve greater concurrency