银行转账问题（死锁）

最新推荐文章于 2024-08-31 20:25:23 发布
最新推荐文章于 2024-08-31 20:25:23 发布
阅读量853 收藏 3
点赞数 2
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qynwang/article/details/131019310
版权

本文主要讲述死锁的一个经典案例—银行转账问题，并对该问题进行定位、修复。

1. 问题说明

当账户A对账户B进行转账时，

  • 首先需要获取到两把锁：账户A和账户B的锁。
  • 获取两把锁成功，且余额大于0，则扣除转出人的余额，并增加收款人的余额，而且这些操作都是在一个原子操作中
  • 获取锁的顺序相反导致死锁，即线程1获取到账户A的锁，然后请求账户B的锁，线程2已经获取到账户B的锁，然后请求A的锁，结果两者互相等待对方的锁，造成死锁。

2. 代码演示

public class TransferMoney implements Runnable {

    Integer flag = 1;

    static Account a = new Account(1000);
    static Account b = new Account(1000);

    //主函数
    public static void main(String[] args) throws InterruptedException {
        TransferMoney t1 = new TransferMoney();
        TransferMoney t2 = new TransferMoney();
        t1.flag = 1;
        t1.flag = 0;

        Thread thread1 = new Thread(t1);
        Thread thread2 = new Thread(t2);

        thread1.start();
        thread2.start();
        thread1.join();
        thread1.join();
        System.out.println("a的余额为："+a.balance);
        System.out.println("a的余额为："+b.balance);
    }
    
    @Override
    public void run() {
        if (flag == 1) {
            transferMoney(a, b, 500);
        }
        if (flag == 0) {
            transferMoney(b, a, 500);
        }
    }
    
    // 转账
    private void transferMoney(Account from, Account to, int amount) {
        synchronized (from) {
            System.out.println(Thread.currentThread().getName()+"获取到第一把锁");
            //加入线程睡眠500ms
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            synchronized (to) {
                System.out.println(Thread.currentThread().getName()+"获取到第二把锁");
                if (from.balance - amount < 0) {
                    System.out.println("余额不足，转账失败。");
                    return;
                }

                from.balance -= amount;
                to.balance += amount;
                System.out.println("成功转账" + i + "元");
            }
        }
    }


    static class Account {
        //余额
        int balance;

        public Account(int balance) {
            this.balance = balance;
        }
    }
}

打印结果：

启动程序，发现打印结果输出几句之后就不再输出，而且程序也未停止，这就发生了死锁。

  • 当线程 thread1 执行transferMoney()方法的时候，他拿到from锁，也就是里面的类成员变量a；
  • 经过 500ms，这个期间线程thread2进来执行transferMoney()方法，拿到from锁，也就是类成员变量b
  • 接下来500ms之后线程thread1继续执行，但是他要拿到to锁，也就是他的成员变量b，但是已经被线程thread1拿过去作为他的from锁了
  • 线程thread2接下来拿他的to锁，也就是成员变量a，但是他已经被线程thread1拿着了，因为成员变量a是线程1的from锁；

所以就进入了死锁的情况。

下面模拟多人转账，多个线程陷入死锁：

public class MultiTransferMoney {

    private static final int NUM_ACCOUNTS = 5000;//账号数
    private static final int NUM_MONEY = 1000;//余额
    private static final int NUM_ITERATIONS = 10000000;//转账次数
    private static final int NUM_THREADS = 20;//转账人数

    public static void main(String[] args) {
        Random random = new Random();
        TransferMoney.Account[] accounts = new TransferMoney.Account[NUM_ACCOUNTS];

        //初始化
        for (int i = 0; i < accounts.length; i++) {
            accounts[i] = new TransferMoney.Account(NUM_MONEY);
        }

        //转账类
        class TransferThread extends Thread{
            @Override
            public void run() {
                for (int i = 0; i < NUM_ITERATIONS; i++) {
                    //随机下标
                    int fromAcct = random.nextInt(NUM_ACCOUNTS);
                    int toAcct = random.nextInt(NUM_ACCOUNTS);
                    int amount = random.nextInt(NUM_ACCOUNTS);

                    transferMoney(accounts[fromAcct], accounts[toAcct],amount);
                }
                System.out.println("程序结束！！！！");
            }
            private void transferMoney(Account from, Account to, int amount) {
                synchronized (from) {
                    synchronized (to) {
                        if (from.balance - amount < 0) {
                            System.out.println("余额不足，转账失败。");
                            return;
                        }

                        from.balance -= amount;
                        to.balance += amount;
                        System.out.println("成功转账" + i + "元");
                    }
                }
            }
        }

        //线程数
        for (int i = 0; i < NUM_THREADS; i++) {
            new TransferThread().start();
        }

    }
}

打印结果：

在多人同时转账的情况下，虽然很人数很多，发生死锁的概率变小，但是只要发生死锁的风险存在，随着时间的推移，就一定会导致程序陷入死锁（墨菲定律）。

3. 如何定位死锁的位置（以两人转账的代码为例）

（1）jstack 命令

通过使用java自带的jstack命令，来查找我们项目中的死锁问题

## 需要首先获取程序的进程 pid
jps
## 然后在 终端界面执行如下命令
jstack 8359  #javahome下的jastack命令 进程的pid

执行结果图：

可以清晰地看到 Thread-1 拿到了锁 <0x000000076adae688> ,正在等待 <0x000000076adae678>，而 Thread-0 拿到了锁 <0x000000076adae678>，正在等待 <0x000000076adae688>，于是两者互相等待，造成死锁。

（2）ThreadMXBean代码
/**
 *      通过 ThreadMXBean 检测死锁
 */
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

public class ThreadMXBeanDetection implements Runnable{
    int flag = 1;//标记位
    static Object lock1 = new Object();
    static Object lock2 = new Object();

    public static void main(String[] args) throws InterruptedException {
        ThreadMXBeanDetection r1 = new ThreadMXBeanDetection();
        ThreadMXBeanDetection r2 = new ThreadMXBeanDetection();
        r1.flag=1;
        r2.flag=0;
        Thread thread1 = new Thread(r1);
        Thread thread2 = new Thread(r2);

        thread1.start();
        thread2.start();
        Thread.sleep(1000);

        //得到实例
        ThreadMXBean threadMXBean = ManagementFactory.getThreadMXBean();
        long[] deadlockedThreads = threadMXBean.findDeadlockedThreads();
        //发现死锁
        if (deadlockedThreads != null && deadlockedThreads.length>0){
            //迭代
            for (long item : deadlockedThreads) {
                //获取线程信息
                ThreadInfo threadInfo = threadMXBean.getThreadInfo(item);
                //获取死锁线程的名字
                System.out.println("发现死锁："+threadInfo.getThreadName());
            }
        }
    }

    @Override
    public void run() {
        System.out.println("flag= " + flag);
        if (flag == 1) {
            synchronized (lock1){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock2){
                    System.out.println(flag);
                }
            }
        }
        if (flag == 0) {
            synchronized (lock2){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (lock1){
                    System.out.println(flag);
                }
            }

        }
    }
}

打印结果：

如上图所示，ThreadMXBean 可以检测死锁，如果我们检测到了之后，就可以编写对应的逻辑，比如重启线程、通知告警系统、发消息提醒运维人员等。

4. 死锁修复（以两人转账的代码为例）

本公众号的《死锁细究》这篇文章提到多种死锁修复的方案。

本文使用死锁避免策略：把获取两把锁的规则改一下，原来的规则是先获取转出人的锁，再获取收款人的锁，这就会造成两个转出人都在等对方释放锁的情况。

现在我们把规则改成：所有的交易都先获取hash值更小的锁，获取到了hash小的锁才能获取hash大的锁，这就避免了环形的死锁，假如说这两个锁的大小一样，这时候就需要一把额外的锁来进行交易流程的控制，相当于一场“加时赛”。

在实际业务开发中可以使用主键，因为主键是唯一的，可以用主键来决定获取锁的顺序。

代码展示：

public class TransferMoney implements Runnable {

    private int flag = 1;
    private static Account a = new Account(500);
    private static Account b = new Account(500);
    private static Object lock = new Object();

    public static void main(String[] args) throws InterruptedException {
        TransferMoney r1 = new TransferMoney();
        TransferMoney r2 = new TransferMoney();
        r1.flag = 1;
        r2.flag = 0;
        //定义两个线程，flag = 1和0分别模拟a和b
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("a的余额" + a.balance);
        System.out.println("b的余额" + b.balance);
    }

    @Override
    public void run() {
        if (flag == 1) {
            //a转账给b
            transferMoney(a, b, 200);
        }
        if (flag == 0) {
            //b转账给a
            transferMoney(b, a, 200);
        }
    }

    /**
     * 转账方法
     *
     * @param from   转出人
     * @param to     收款人
     * @param amount 转账金额
     */
    public static void transferMoney(Account from, Account to, int amount) {

        /**
         * 辅助类
         */
        class Helper {
            public void transfer() {
                if (from.balance - amount < 0) {
                    System.out.println("余额不足，转账失败。");
                    return;
                }
                from.balance -= amount;
                to.balance = to.balance + amount;
                System.out.println("成功转账" + amount + "元");
            }
        }

        //使用类的hash值来帮助排序
        int fromHash = System.identityHashCode(from);
        int toHash = System.identityHashCode(to);
        
        // 通过System.identityHashCode(XXX)去获取对象的hash值，并进行比较他们的hash值来进行比较来决定拿锁的顺序
        if (fromHash < toHash) {
            synchronized (from) {
                System.out.println(Thread.currentThread().getName() + "获取到第一把锁");
                synchronized (to) {
                    System.out.println(Thread.currentThread().getName() + "获取到第二把锁");
                    new Helper().transfer();
                }
            }
        } else if (fromHash > toHash) {
            synchronized (to) {
                System.out.println(Thread.currentThread().getName() + "获取到第一把锁");
                synchronized (from) {
                    System.out.println(Thread.currentThread().getName() + "获取到第二把锁");
                    new Helper().transfer();
                }
            }
        } else {
            //发生hash碰撞时，可以增加第三把锁来进行控制，类似“加时赛”
            synchronized (lock) {
                synchronized (to) {
                    System.out.println(Thread.currentThread().getName() + "获取到第一把锁");
                    synchronized (from) {
                        System.out.println(Thread.currentThread().getName() + "获取到第二把锁");
                        new Helper().transfer();
                    }
                }
            }
        }
    }

    /**
     * 收款账户
     */
    static class Account {

        public Account(int balance) {
            this.balance = balance;
        }
        int balance;
    }
}

打印结果：

程序不再死锁！！！

文章来源：银行转账问题（死锁）

个人微信：CaiBaoDeCai

微信公众号名称：Java知者

微信公众号 ID： JavaZhiZhe

谢谢关注！

Java知者
关注
java 转账 锁_java 关于高并发下的银行转账问题
weixin_28725959的博客
02-16 1328
在转账操作中，一致性必须要保证的，转账的前后，各个账户的金额必须符合算术一致性如何保证一致性？ 引入事务机制是肯定的，但是这就够了么，下面我们对其进行测试场景：小明账户中有10000元，小强账户中有10000元，小红账户中有0元有三个操作同时进行：小明给小红转账10元 ，小强给小红转账10元，小红自己往账户存入1元为了模拟高并发，我这里将上述操作复制300份，每份300个线程中同时执行测试一：代码...
Java并发编程--死锁及模拟银行转账实现
zwt122755527的博客
12-23 2032
死锁DeadLock 死锁是指两个或两个以上的线程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程称为死锁进程。 模拟银行转账的Demo 下面我们来看一个关于银行转账的死锁例子。在银行转账问题中，我们需要对转出方和转入方两个账户加锁，以确保转账过程中金额的正确性。 我...
用多线程实现简单的银行转账系统
最新发布
weixin_62630130的博客
08-31 217
Java基础线程练习题
银行转账带来的死锁问题
程序员的规则
03-24 376
如果只是单纯的进行两个账户之间的转账，那么久很容易导致死锁问题 std::mutex mxA; std::mutex mxB; int countA = 1000; int countB = 1000; void thread_fun1(int money) { std::unique_lock<std::mutex>lcA(mxA); cout << "线程1获得了A账户的锁" << endl; if (countA > money) { cout
java 转账 锁_Java并发编程-死锁（上）：追求性能的代价
weixin_34987986的博客
02-16 414
前面几篇文章，我们一直在关注如何解决并发问题，也就是程序的原子性、可见性、有序性。这些问题一旦出现，程序的结果就没法保证。好在 Java 是一门强大的语言，锁-synchronized 是一味万能药。你只要用好锁，几乎能解决所有并发问题。不过，并发编程有一个特点：解决完一个问题，总会冒出另一个新问题。锁带来的性能问题实际开发中，锁虽然是一副万能药，但使用起来要非常小心。因为你不但要考虑锁和资源的关...
Java高并发场景（银行转账问题）
zhangximing的博客
05-11 1680
Java高并发场景（银行转账问题）分析
银行转账的死锁问题
qq_42672654的博客
05-30 2796
1.概述：银行转账问题（A给B转账1000元，涉及到两个用户的现金余额的事务） 1、转账业务是一种事务，所以需要保证数据的安全性。注意是一个原子性操作 如果A用户余额大于要转出金额，则扣除转出人的余额。 如果A用户余额小于要转出金额，则无法扣除转出人的余额，停止转账提醒转出人转账失败。 在转账中途如果出现错误（A账户转出扣除成功，B账户增加失败/A给B转账同时B给A转账，获取锁的顺序相反导致死锁），需要将数据进行回滚。 2、对于一个转账操作，需要2把锁，一个锁锁住转出账户的余额，一把锁锁住转入账户的
Java并发学习三：银行转账的死锁问题解决及示例
个人博客
12-02 2775
Java并发学习系列文章：Java并发学习-博客专栏 今天在学习极客时间专栏：《Java并发编程实战》 从03 | 互斥锁（上）：解决原子性问题到06 | 用“等待-通知”机制优化循环等待。 课程主要用银行转账作为解决死锁的例子。 在转账过程中需要2把锁，一个锁锁住转出账户的余额，一把锁锁住转入账户的余额。但加锁的先后顺序会使程序产生死锁。 有以下这四个条件都发生时才会出现死锁： 1.互斥，共...
死锁---转账问题
zhangpower1993的博客
04-25 3597
1. 转账死锁场景 场景：简单的银行转账，将资金从一个账户（fromAccount）转到另一个账户（toAccount），当并发执行的时候，可能会出现死锁的情况； 死锁的场景：多线程执行，线程1:账户A转账给账户B；线程2:账户B转账给账户A；线程1和线程2同时转账时，就可能会发生 死锁： 线程1：new TransferAccount(fromAccount,toAccou...
java多线程模拟处理银行的实时转账交易
12-15
在Java编程领域，多线程技术是实现并发执行任务的关键工具，尤其在处理实时系统如银行转账交易时显得尤为重要。银行转账涉及到多个账户之间的资金流动，这种操作通常需要高效、安全且并发地进行。本项目"java多线程...
通过银行转账问题解说死锁解决方案
小嗨嗨的博客
02-19 2901
大家都知道，在并发情况下对两个账户进行转账操作可能会产生死锁，可能出现死锁的原因是,并发情况下对两个账户的操作无法保证其执行顺序。 1. 并发问题描述 假如现在执行下面的操： 线程一执行的是：【账户A】给【账户B】转账 线程二执行的是：【账户B】给【账户A】转账 如果两个转账动作同时执行,则会出现线程一会请求对【账户B】进行加锁,线程二会请求对【账户A】进行加锁 由于此时的【账户A】已...
支付系统转账过程中并发交易引起的分布式死锁问题
天将降大任于是人
09-05 7412
死锁死锁的规范定义：集合中的每一个进程都在等待只能由本集合中的其他进程才能引发的事件，那么该组进程是死锁的。从广义上讲，这里的进程指的是一个执行单元。问题描述假设【账户A】给 【账户B】转账 500 元，在程序中的转账逻辑如下： 1. 开启事务 2. 【账户A】的余额减去 500 元 3. 【账户B】的余额增加 500 元 4. 提交事务在集群环境下，在 server1、server
Java多线程 死锁转账案例
Java持续实践
09-08 907
文章目录两个转账的死锁demo 两个转账的死锁demo 需要两把锁: 转账时, 锁住自己的账户, 同时只能有一个线程去执行转账. 获取两把锁成功, 且余额大于0 , 则扣除转出人的钱, 增加收款人的钱. 并且是原子操作. 出现死锁的情况: 对方给我转钱 ,我也给对方转钱, 那么双方都持有自己的锁, 并且需要对方的锁, 这就造成了死锁. 如下的代码演示了转账死锁的发生. 在run方法中, 根据不同线程的flag 执行不同的转账方法,分别给a和b相互的转账. transferMoney方法就是转账的方法. 在转
【java_多线程】模拟银行转账，为保证原子性而引发死锁，检测死锁并解决
chenghan_yang的博客
11-22 1399
前言 本例子不是实际的生产模型，只是为了更好研究死锁而举的例子 需求 james 转账给 jay 20 元，需要保证转账过程原子性操作 能加锁的前提 每个对象都有一个monitor，用于维护自身的锁状态，换句话说，所有对象都可以作为一把锁 每个用户的monitor就可以作为一把锁，并且这把锁是互斥的，暂且称作读写锁 用加锁实现原子性 锁规则 每个用户都持有账户的一把读写锁，可以自己持有，也可以被...
转账该如何加锁？
weixin_39407955的博客
05-28 417
以下内容只是学习参考，不适用于分布式场景银行业务里面的转账操作，账户 A 减少 100 元，账户 B 增加 100 元。这两个账户就是有关联关系的。那对于像转账这种有关联关系的操作，我们应该怎么去解决呢？我们声明了个账户类：Account，该类有一个成员变量余额：balance，还有一个用于转账的方法：transfer()，然后怎么保证转账操作 transfer() 没有并发问题呢？
java并发系列之：死锁
成为一位优秀的职场人，我在路上
05-20 553
在本文中，我们将探讨死锁的概念及其产生的原因，并通过示例代码来说明死锁的出现情况。我们还将介绍如何通过破坏死锁的不同条件来解决死锁问题，通过深入了解死锁及其解决方法，我们可以更好地应对并解决系统中可能出现的死锁情况。本文简单描述了死锁的概念、产生死锁需要满足的四个条件、破坏死锁不同条件的思路和示例。在实战中如何预防死锁、排查死锁，将在后面的文章中补充。若文章中有描述不清或者有误的地方，欢迎评论区讨论与指正！
340-写一个银行转账死锁问题并且解决
LINZEYU666的博客
07-04 402
实现银行转账的死锁 #include <mutex> #include <iostream> #include <thread> #include <condition_variable> using namespace std; mutex mxA; mutex mxB; int countA = 1000; int countB = 1000; void thread_func1(int money) //A---> B转账money元 {
java并发编程系列——死锁的解决
守夜人爱吃兔子的博客
08-13 388
接下来我会以一个经典的转帐问题，跟大家一起聊聊死锁，以及如何解决这个问题。 假如客户 A 需要给客户 B 转账，客户 A 的账户减少 100 元，客户 B 的账户增加 100 元。 我们转化为代码描述：有一个账户类 Account，账户类有一个转账方法 transfer() 方法，该方法接收两个参数，转入账户和转账金额。 示例：1 public class Account { private int balance; public void transfer(Account t
几种常见的死锁问题
qq_41681715的博客
09-13 1107
在开发多线程程序时，难免会遇到死锁的问题，这里说下我在开发中遇到的几种常见的死锁问题： 1、线程1先加锁A，然后再加锁B，线程2先加锁B，再加锁A 为避免这种情况，在编程时尽量减小没把锁的范围，同时尽量避免多个线程对几把锁加锁顺序不同的情况，以免出现互锁导致死锁的现象。 2、同一个线程出现对同一把锁，在未解锁的情况下，多次加锁 3、同一个线程，在加锁后，由于某种异常情况没有处理，导致for循环或while循环一直不能退出且锁一直被该线程占用，导致其它使用该锁的线程一直阻塞，下面是一段伪代...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值