Java通过锁的顺序避免死锁

雨点打透心脏的1/2处 2022-07-26 04:23 178阅读 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 条评论，178人围观）

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

相关阅读

相关 Java并发问题：锁竞争与死锁避免

Java并发编程中，锁竞争和死锁是两个常见的问题。下面我将分别解释这两个问题，并提供一些避免它们的策略。 ###锁竞争**锁竞争**是指多个线程同时尝试获取同一个锁时发生的情

水深无声/ 2024年11月13日 01:48/ 0 赞/ 7 阅读

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

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

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

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

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

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

相关形成死锁的条件以及如何避免死锁

死锁是指在并发系统中，两个或多个进程或线程因为互相等待对方释放资源而无法继续执行的状态。死锁的发生通常需要满足以下四个条件： 1. 互斥条件（Mutual Exclusion

落日映苍穹つ/ 2024年03月23日 19:03/ 0 赞/ 59 阅读

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

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

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

相关 java如何避免死锁

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

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

相关死锁的原因、条件和避免死锁的方法

产生死锁的原因主要是：（1）因为系统资源不足。（2）进程运行推进的顺序不合适。（3）资源分配不当等。产生死锁的四个必要条件：（1）互斥条件：

深藏阁楼爱情的钟/ 2022年08月05日 05:28/ 0 赞/ 207 阅读

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

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

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

相关同步锁以及如何避免死锁？

同步：在高并发的情况下，为了防止数据出错，一个线程对于共享资源执行操作的时候，另外的线程要执行操作此共享资源需要等待前一个线程释放此共享资源，才能操作。同步监视器：共享资源

小咪咪/ 2022年04月24日 08:04/ 0 赞/ 400 阅读

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

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

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