Java通过锁的顺序避免死锁

雨点打透心脏的1/2处 2022-07-26 04:23 227阅读 0赞

# 例子 #

银行账户转账问题，两个用户转账的话，如果采用一般的synchronized嵌套的话，容易造成死锁，现在我们通过类似哲学家问题的解决方案一样：先获取同一个锁，才有资格获取下一个。而判断是通过System.identityHashCode（）来生成类的hashcode（）的返回值作为唯一标识，相同的话，我们再加一把锁。

// 死锁版本
    class Account {
        private int money;
    
        public Account(int money) {
            this.money = money;
        }
    
        public void debit(int amount) {
            System.out.println("after debit " + amount + " " + this.money + " -> " + (this.money-amount));
            this.money -= amount;
        }
    
        public void credit(int amount) {
            System.out.println("after credit " + amount + " " + this.money + " -> " + (this.money+amount));
            this.money += amount;
        }
    
        public int get() {
            return this.money;
        }
    }
    
    public class OrderLock {
        
        private static final Object tieLock = new Object();
    
        public void transferMoney(final Account fromAcct, final Account toAcct, final int amount) 
                throws InsufficientResourcesException {
            class Helper {
                public void transfer() throws InsufficientResourcesException {
                    if (fromAcct.get() < amount) 
                        throw new InsufficientResourcesException();
                    else {
                        fromAcct.debit(amount);
                        toAcct.credit(amount);
                    }
                }
            }
    
            // 两个用户使用这两个账户给对方转账时，死锁；因为一方fromAcct账户为对方的toAcct账户
            synchronized (fromAcct) {
                synchronized (toAcct) {
                    new Helper().transfer();
                }
            }
        }
    
        class MyThread implements Runnable {
            private Account fromAcct;
            private Account toAcct;
            private int amount;
    
            public MyThread(Account fromAcct, Account toAcct, int amount) {
                this.fromAcct = fromAcct;
                this.toAcct = toAcct;
                this.amount = amount;
            }
    
    
            @Override
            public void run() {
                try {
                    transferMoney(this.fromAcct, this.toAcct, this.amount);
                } catch (InsufficientResourcesException e) {
                    System.out.println("操作失败");
                }
            }
    
        }
    
        public static void main(String[] args) {
            Account fromAcct = new Account(100);
            Account toAcct = new Account(230);
            OrderLock orderLock = new OrderLock();
            ExecutorService threadPool = Executors.newCachedThreadPool();
            for (int i = 0; i < 5; i++) {
                if ((i & 1) == 0)
                    threadPool.execute(orderLock.new MyThread(fromAcct, toAcct, 10));
                else threadPool.execute(orderLock.new MyThread(toAcct, fromAcct, 10));
            }
        }
    }

// 解决死锁版本
    class Account {
        private int money;
    
        public Account(int money) {
            this.money = money;
        }
    
        public void debit(int amount) {
            System.out.println("after debit " + amount + " " + this.money + " -> " + (this.money-amount));
            this.money -= amount;
        }
    
        public void credit(int amount) {
            System.out.println("after credit " + amount + " " + this.money + " -> " + (this.money+amount));
            this.money += amount;
        }
    
        public int get() {
            return this.money;
        }
    }
    
    public class OrderLock {
        
        private static final Object tieLock = new Object();
    
        public void transferMoney(final Account fromAcct, final Account toAcct, final int amount) 
                throws InsufficientResourcesException {
            class Helper {
                public void transfer() throws InsufficientResourcesException {
                    if (fromAcct.get() < amount) 
                        throw new InsufficientResourcesException();
                    else {
                        fromAcct.debit(amount);
                        toAcct.credit(amount);
                    }
                }
            }
    
            // 转账双方共用这两个账户的对象，否则无法通过下面方式排序下面的锁顺序
            int fromHash = System.identityHashCode(fromAcct);
            int toHash = System.identityHashCode(toAcct);
    
            if (fromHash < toHash) {
                synchronized (fromAcct) {
                    synchronized (toAcct) {
                        new Helper().transfer();
                    }
                }
            } else if (fromHash > toHash) {
                synchronized (toAcct) {
                    synchronized (fromAcct) {
                        new Helper().transfer();
                    }   
                }
            } else {
                synchronized (tieLock) {
                    synchronized (fromAcct) {
                        synchronized (toAcct) {
                            new Helper().transfer();
                        }
                    }
                }
            }
        }
    
        class MyThread implements Runnable {
            private Account fromAcct;
            private Account toAcct;
            private int amount;
    
            public MyThread(Account fromAcct, Account toAcct, int amount) {
                this.fromAcct = fromAcct;
                this.toAcct = toAcct;
                this.amount = amount;
            }
    
    
            @Override
            public void run() {
                try {
                    transferMoney(this.fromAcct, this.toAcct, this.amount);
                } catch (InsufficientResourcesException e) {
                    System.out.println("操作失败");
                }
            }
    
        }
    
        public static void main(String[] args) {
            // 转账双方共用这两个账户对象
            Account fromAcct = new Account(100);
            Account toAcct = new Account(230);
            OrderLock orderLock = new OrderLock();
            ExecutorService threadPool = Executors.newCachedThreadPool();
            for (int i = 0; i < 5; i++) {
                if ((i & 1) == 0)
                    threadPool.execute(orderLock.new MyThread(fromAcct, toAcct, 10));
                // 注：转账的账户变成了toAcct，被转账的账户变成了fromAcct
                else threadPool.execute(orderLock.new MyThread(toAcct, fromAcct, 10));
            }
        }
    }

# 关于上面代码的疑惑 #

## 1 嵌套synchronized 代码块 ##

synchronized (fromAcct) {
                synchronized (toAcct) {
                    new Helper().transfer();
                }   
        }

理解：嵌套的synchronized是按照嵌套的顺序获取锁，即先获取最外层的锁fromAcct，再获取toAcct的锁。

## 2 fromAcct和toAcct的锁 ##

![这里写图片描述][20160407110637083]

注：转账双发的账户放生了反转，Jack的toAcct变成了Bob的fromAcct

# 死锁的四个必要条件 #

1.  互斥使用（资源独占）  
    一个资源每次只能给一个进程使用
2.  不可抢占（不可剥夺）  
    资源申请者不能强行的从资源占有者手中夺取资源，资源 只能由占有者自愿释放
3.  请求和保持（部分分配，占有申请）  
    一个进程在申请新的资源的同时保持对原有资源的占有（只要这样才是动态申请，动态分配）
4.  循环等待  
    存在一个进程等待队列\{P1, P2, … ，Pn\}，其中P1等待P2占有的资源，P2等待P3占有的资源，…，Pn等待P1占有的资源，星辰给一个进程等待环路

# hashCode和identityHashCode #

*  hashCode()方法时Object类下面的一个方法，供继承类重写，根据对象内存地址计算哈希值，String类重写了hashCode方法，并改为根据字符序列计算哈希值。
 *  identityHashCode()方法是System类中的静态方法，根据对象内存地址来计算哈希值

public static void main(String[] args) {
            // TODO Auto-generated method stub
            String s1 = new String("hello");
            String s2 = new String("hello");
            System.out.println("s1的hashCode值：:" + s1.hashCode());
            System.out.println("s2的hashCode值：:" + s2.hashCode());
            System.out.println("s1的identityHashCode值：:" + System.identityHashCode(s1));
            System.out.println("s2的identityHashCode值：:" + System.identityHashCode(s2));
            System.out.println("--------------------------");
            String s3 = "Java";
            String s4 = "Java";
            System.out.println("s3的hashCode值：:" + s3.hashCode());
            System.out.println("s4的hashCode值：:" + s4.hashCode());
            System.out.println("s3的identityHashCode值：:" + System.identityHashCode(s3));
            System.out.println("s4的identityHashCode值：:" + System.identityHashCode(s4));
        }
    
    // print
    s1的hashCode值：:99162322
    s2的hashCode值：:99162322
    s1的identityHashCode值：:817899724
    s2的identityHashCode值：:397836821
    --------------------------
    s3的hashCode值：:2301506
    s4的hashCode值：:2301506
    s3的identityHashCode值：:1326857436
    s4的identityHashCode值：:1326857436

# 参考 #

[Java通过锁的顺序避免死锁][Java]  
[hashCode和identityHashCode的区别][hashCode_identityHashCode]

[20160407110637083]: /images/20220724/6d982bd51a514f48a566cabf1766ea32.png
[Java]: http://www.lxway.com/4422815506.htm
[hashCode_identityHashCode]: http://www.2cto.com/kf/201409/332998.html

发表评论取消回复

表情：

评论列表（有 0 条评论，227人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java并发编程：死锁和避免死锁的方法

死锁是多线程编程中的一种严重问题，会导致所有线程都无法继续执行任务。以下是死锁的特征和一些避免死锁的方法： 1. **特征**： - **互斥**：资源被多个线程同时请

待我称王封你为后i/ 2024年09月11日 05:42/ 0 赞/ 173 阅读

相关什么是死锁？如何避免死锁？

概念线程死锁描述的是这样一种情况：多个线程同时被阻塞，它们中的一个或者全部都在等待某个资源被释放。由于线程被无限期地阻塞，因此程序不可能正常终止。 > 我和同学都打扫

以你之姓@/ 2024年04月03日 07:00/ 0 赞/ 240 阅读

相关死锁以及如何避免死锁

死锁以及如何避免死锁死锁的定义死锁通常涉及的四个必要条件 1. 互斥条件 2. 占有且等待条件 3. 非抢占条件

骑猪看日落/ 2024年02月21日 11:14/ 0 赞/ 181 阅读

相关如何避免死锁？

死锁是指在多线程程序中，当两个或更多的线程相互等待，无限期地等待其他线程释放资源时发生的情况。为了避免死锁，我们可以采取以下一些策略： 1. 避免使用共享资源：尽可能避免多

不念不忘少年蓝@/ 2024年02月05日 21:17/ 0 赞/ 55 阅读

相关死锁终结者：顺序锁和轮询锁！

![2c00cf123c6b1af2546d31ad5abc10d4.png][] 作者 | 王磊来源 | Java中文社群（ID：javacn666）转载请联系授权

红太狼/ 2023年10月03日 15:32/ 0 赞/ 83 阅读

相关如何避免死锁？

如何避免死锁？文章目录 8. 如何避免死锁？ -------------------- 8. 如何避免死锁？ ![201907292146597

今天药忘吃喽~/ 2023年10月01日 11:38/ 0 赞/ 62 阅读

相关死锁是什么？如何避免死锁？

死锁是什么，以及在并发程序中如何避免死锁一直是面试官偏爱的一个问题。本文尽量以最简洁的示例来帮助你快速理解，掌握死锁发生的原因及其解决方法。在阅读接下来的内容之前，你必须具备

深碍√TFBOYSˉ_/ 2023年05月28日 14:26/ 0 赞/ 113 阅读

相关 java如何避免死锁

文章目录一、什么是死锁二、怎么排查死锁三、死锁产生的4个必要条件四、避免死锁的方法一、什么是死锁 java中的死锁是一种编程情况

浅浅的花香味﹌/ 2022年12月20日 02:10/ 0 赞/ 284 阅读

相关 Java通过锁的顺序避免死锁

例子银行账户转账问题，两个用户转账的话，如果采用一般的synchronized嵌套的话，容易造成死锁，现在我们通过类似哲学家问题的解决方案一样：先获取同一个锁，才有资格

雨点打透心脏的1/2处/ 2022年07月26日 04:23/ 0 赞/ 228 阅读

相关 MySQL锁(锁级别、锁优化、避免死锁)

MySQL锁为了保证数据的一致完整性，任何一个数据库都存在锁定机制。锁定机制的优劣直接影响到一个数据库系统的并发处理能力和性能，所以锁定机制的实现也就成为了各种数据库的

﹏ヽ暗。殇╰゛Y/ 2021年11月29日 20:30/ 0 赞/ 492 阅读