Java多线程银行账户同步：利用wait/notifyAll机制实现安全存取

package BPA;

import java.util.Random;

public class Cuenta {

    private int saldo; // 当前余额
    private final int saldoMax; // 最大余额
    private final int saldoMin = 1; // 最小余额

    public Cuenta(int saldoInicial, int saldoMaximo) {
        this.saldo = saldoInicial;
        this.saldoMax = saldoMaximo;
    }

    /**
     * 取款操作
     * @param nombre 执行操作的人名
     * @param cuenta 账户实例 (虽然参数中包含，但实际操作的是当前对象)
     */
    public synchronized void retiro(String nombre, Cuenta cuenta) {
        int dinero;
        Random rnd = new Random();
        // 随机生成取款金额，范围在0到349之间
        dinero = (int) (rnd.nextDouble() * 350.0);

        // 检查取款后是否会低于最小余额
        while ((saldo - dinero) <= saldoMin) {
            System.out.println("  ****  余额不足！" + nombre + " 尝试取出: " + dinero + " 欧元. 当前余额: " + getSaldo() + " 欧元. ****");
            System.out.println(" ---- " + nombre + " 正在等待存款，以便能取出更多钱 ---- ");
            try {
                // 余额不足，当前线程等待，并释放Cuenta对象的锁
                wait(); 
            } catch (InterruptedException e) {
                System.out.println("取款等待被中断");
                Thread.currentThread().interrupt(); // 重新设置中断标志
            }
            // 唤醒后，重新检查条件，防止虚假唤醒
            dinero = (int) (rnd.nextDouble() * 350.0); // 重新生成取款金额
        }

        // 条件满足，执行取款
        this.saldo = this.saldo - dinero;
        System.out.println("Name: " + nombre + " 取出: " + dinero + " 欧元. 总余额: " + getSaldo() + " 欧元.");
        // 唤醒所有在Cuenta对象上等待的线程，可能是等待存款的，也可能是等待取款的
        notifyAll(); 
    }

    /**
     * 存款操作
     * @param nombre 执行操作的人名
     * @param cuenta 账户实例 (虽然参数中包含，但实际操作的是当前对象)
     */
    public synchronized void ingreso(String nombre, Cuenta cuenta) {
        int dinero;
        Random rnd = new Random();
        // 随机生成存款金额，范围在0到349之间
        dinero = (int) (rnd.nextDouble() * 350.0);

        // 检查存款后是否会超出最大余额
        while ((saldo + dinero) > saldoMax) {
            System.out.println(" **** 账户已满！" + nombre + " 尝试存入: " + dinero + " 欧元. 当前余额: " + getSaldo() + " 欧元. ****");
            System.out.println(" ---- " + nombre + " 正在等待取款，以便能存入更多钱 ---- ");
            try {
                // 余额已满，当前线程等待，并释放Cuenta对象的锁
                wait(); 
            } catch (InterruptedException e) {
                System.out.println("存款等待被中断");
                Thread.currentThread().interrupt(); // 重新设置中断标志
            }
            // 唤醒后，重新检查条件，防止虚假唤醒
            dinero = (int) (rnd.nextDouble() * 350.0); // 重新生成存款金额
        }

        // 条件满足，执行存款
        this.saldo = this.saldo + dinero;
        System.out.println("Name: " + nombre + " 存入: " + dinero + " 欧元. 总余额: " + getSaldo() + " 欧元.");
        // 唤醒所有在Cuenta对象上等待的线程
        notifyAll(); 
    }

    public int getSaldo() {
        return saldo;
    }
}

package BPA;

import java.util.logging.Level;
import java.util.logging.Logger;

public class Persona extends Thread {

    String nombre;
    private Cuenta cuenta;

    public Persona(String nombre, Cuenta cuenta) {
        this.nombre = nombre;
        this.cuenta = cuenta;
    }

    @Override
    public void run() {
        while (true) {
            // 线程循环进行存款和取款操作
            cuenta.ingreso(nombre, cuenta);
            cuenta.retiro(nombre, cuenta);
            try {
                // 为了模拟真实场景和避免CPU空转，线程可以短暂休眠
                Thread.sleep(500); // 每次操作后休眠500毫秒
            } catch (InterruptedException e) {
                System.out.println(nombre + " 的操作被中断.");
                Thread.currentThread().interrupt(); // 重新设置中断标志
                break; // 线程中断时退出循环
            }
        }
    }
}

package BPA;

import java.util.logging.Level;
import java.util.logging.Logger;

public class BPA {
    public static void main(String[] args) {
        // 创建一个共享账户实例，初始余额40欧元，最大余额500欧元
        Cuenta laCuenta = new Cuenta(40, 500);

        // 创建两个Persona线程，共享同一个Cuenta实例
        Persona Ramon = new Persona("Ramon", laCuenta);
        Persona Quique = new Persona("Quique", laCuenta);

        // 启动线程
        Quique.start();
        Ramon.start();

        try {
            // 主线程等待两个Persona线程执行完毕
            // 在此示例中，Persona线程是无限循环，所以join()会一直等待
            // 如果希望程序在特定条件或时间后停止，需要额外的中断逻辑
            Quique.join();
            Ramon.join();
        } catch (InterruptedException ex) {      
            System.out.println("主线程等待被中断");
            Thread.currentThread().interrupt();
        }
    }
}