Java模拟取钱排队 java实现银行取钱

转载

mob64ca14061c9e 2024-05-15 10:30:34

文章标签 Java模拟取钱排队 System 线程安全同步方法 文章分类 Java 后端开发

Java线程安全和线程同步（银行取钱案例）

一、线程安全问题

案例：银行多用户操作同一账户

public class SafeBank {
    public static void main(String[] args) {
        Account account = new Account("建行卡", 100);
        new Thread(new Bank(account,50),"小明").start();
        new Thread(new Bank(account,100),"小明老婆").start();
    }
}

class Account {

    String name;
    int money;

    public Account(String name, int money) {
        this.name = name;
        this.money = money;
    }
}

class Bank implements Runnable{

    Account account;
    int needMoney;

    public Bank(Account account, int needMoney) {
        this.account = account;
        this.needMoney = needMoney;
    }

    @Override
    public void run() {
        getMoney();
    }

    public void getMoney() {
        if (account.money <= 0) {
            System.out.println("余额不足");
            return;
        }
        if (needMoney > account.money) {
            System.out.println(Thread.currentThread().getName() + "想取钱，但余额不足");
            return;
        }
        System.out.println(Thread.currentThread().getName() + "取了" + needMoney + "万");
        account.money -= needMoney;
        System.out.println("账户剩余" + account.money + "万");
    }
}

运行结果

Java模拟取钱排队 java实现银行取钱_Java模拟取钱排队

为什么会这样？
代码逻辑无问题，但由于同时开了两个account目标对象的线程，存在线程安全问题。要解决这个问题，需要用到线程同步

二、线程同步

同步方法

public class SafeBank {
    public static void main(String[] args) {
        Account account = new Account("建行卡", 100);
        new Thread(new Bank(account,50),"小明").start();
        new Thread(new Bank(account,100),"小明老婆").start();
    }
}

class Account {

    String name;
    int money;

    public Account(String name, int money) {
        this.name = name;
        this.money = money;
    }
}

class Bank implements Runnable{

    Account account;
    int needMoney;

    public Bank(Account account, int needMoney) {
        this.account = account;
        this.needMoney = needMoney;
    }

    @Override
    public void run() {
        getMoney();
    }

    public synchronized void getMoney() {
        if (account.money <= 0) {
            System.out.println("余额不足");
            return;
        }
        if (needMoney > account.money) {
            System.out.println(Thread.currentThread().getName() + "想取钱，但余额不足");
            return;
        }
        System.out.println(Thread.currentThread().getName() + "取了" + needMoney + "万");
        account.money -= needMoney;
        System.out.println("账户剩余" + account.money + "万");
    }
}

运行结果：

Java模拟取钱排队 java实现银行取钱_线程安全_02

由运行结果可以看出，还是没解决线程安全问题，为什么？

因为同步方法，默认锁的对象时this，即本类，在此案例中，this代指Bank，而发生变化的数据是account对象的，因此synchronized关键字并没有锁住该目标对象，因此运行结果仍然存在线程安全问题，怎么解决呢，这里可以只用同步块的方式来解决

同步块

同步块 : synchronized (Obj ) { }
Obj ：同步监视器， Obj 可以是任何对象 , 但是推荐使用共享资源作为同步监视器，同步方法中无需指定同步监视器 , 因为同步方法的同步监视器就是this , 就是这个对象本身 , 或者是 class
同步监视器的执行过程

第一个线程访问 , 锁定同步监视器 , 执行其中代码 .
第二个线程访问 , 发现同步监视器被锁定 , 无法访问 .
第一个线程访问完毕 , 解锁同步监视器 .
第二个线程访问, 发现同步监视器没有锁 , 然后锁定并访问

public class SafeBank {
    public static void main(String[] args) {
        Account account = new Account("建行卡", 100);
        new Thread(new Bank(account,50),"小明").start();
        new Thread(new Bank(account,100),"小明老婆").start();
    }
}

class Account {

    String name;
    int money;

    public Account(String name, int money) {
        this.name = name;
        this.money = money;
    }
}

class Bank implements Runnable{

    Account account;
    int needMoney;

    public Bank(Account account, int needMoney) {
        this.account = account;
        this.needMoney = needMoney;
    }

    @Override
    public void run() {
        getMoney();
    }

    public void getMoney() {
        synchronized (account) {
            if (account.money <= 0) {
                System.out.println("余额不足");
                return;
            }
            if (needMoney > account.money) {
                System.out.println(Thread.currentThread().getName() + "想取钱，但余额不足");
                return;
            }
            System.out.println(Thread.currentThread().getName() + "取了" + needMoney + "万");
            account.money -= needMoney;
            System.out.println("账户剩余" + account.money + "万");
        }
    }
}

运行结果：

Java模拟取钱排队 java实现银行取钱_Java模拟取钱排队_03

由运行结果可以看出线程安全问题已经解决。

同步锁

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步，同步锁由Lock对象充当。比较常用的是ReentrantLock（可重入锁）。
代码格式

public class X {
    //定义锁对象
    private final ReentrantLock lock = new ReentrantLock();
    //定义需要保证线程安全的方法
    public void m(){
        //加锁
        lock.lock();
        try {
            //需要保证线程安全的代码
        }finally {
            //使用finally块来保证释放锁
            lock.unlock();
        }
    }
}

import java.util.concurrent.locks.ReentrantLock;

public class SafeBank {
    public static void main(String[] args) {
        Account account = new Account("建行卡", 100);
        new Thread(new Bank(account, 50), "小明").start();
        new Thread(new Bank(account, 100), "小明老婆").start();
    }
}

class Account {

    String name;
    int money;

    public Account(String name, int money) {
        this.name = name;
        this.money = money;
    }
}

class Bank implements Runnable {
    private final ReentrantLock lock = new ReentrantLock();

    Account account;
    int needMoney;

    public Bank(Account account, int needMoney) {
        this.account = account;
        this.needMoney = needMoney;
    }

    @Override
    public void run() {
        getMoney();
    }

    public void getMoney() {
        lock.lock();
        try {
            if (account.money <= 0) {
                System.out.println("余额不足");
                return;
            }
            if (needMoney > account.money) {
                System.out.println(Thread.currentThread().getName() + "想取钱，但余额不足");
                return;
            }
            System.out.println(Thread.currentThread().getName() + "取了" + needMoney + "万");
            account.money -= needMoney;
            System.out.println("账户剩余" + account.money + "万");

        } finally {
            lock.unlock();
        }
    }

}

运行结果：

Java模拟取钱排队 java实现银行取钱_System_04

从运行结果可以看出，并未能解决线程同步问题，为什么？

使用同步锁与同步方法有点类似，只是使用Lock时显式使用Lock对象作为同步锁，而使用同步方法时系统隐式使用当前对象作为同步监视器。在此处，虽然显式使用了Lock，但锁住的对象仍是Bank，而不是account，因此并没有解决线程安全问题，想要解决此问题，可以将Bank类的方法功能整合到Account类中，然后使用Lock显式调用锁住account。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。