java编程实战第十章笔记

最新推荐文章于 2024-10-28 15:14:46 发布

原创最新推荐文章于 2024-10-28 15:14:46 发布 · 189 阅读

0 ·

CC 4.0 BY-SA版权

java并发编程专栏收录该内容

17 篇文章

订阅专栏

本文详细解析了死锁的概念及避免策略，包括定义、死锁的简单形式、动态锁顺序死锁的原因与解决办法。此外，还介绍了其它活跃性危险如饥饿与活锁等现象。

第十章避免活跃性危险

一死锁

死锁定义：当一个线程永远占有一个锁, 而其他线程尝试去获得这个锁, 那么它们将永远被阻塞。

例如：当线程占有锁L时, 想要获得锁M, 但是同时, 线程B持有M, 并尝试获得L, 两个线程将永远等待下去, 这种情况是死锁的最简单的形式

锁顺序死锁

发生原因：当两个线程试图以不同的顺序来获得相同的锁时，例如

public class Test {
    private final Object left = new Object();
    private final Object right = new Object();

    public void leftRight(){
        synchronized (left) {
            synchronized (right) {
                //do
            }
        }
    }

    public void rightLeft(){
        synchronized (right) {
            synchronized (left) {
                //do
            }
        }
    }
}

动态的锁顺序死锁

有时候，并不能清楚地知道是否在锁顺序上有足够的控制权来避免死锁的发生。例如以下代码：

public void transferMoney(Account fromAccount, Account toAccount, DollarAmount amount) {  
    synchronized (fromAccount) {  
        synchronized (toAccount) {  
            if (fromAccount.getBalance().compareTo(amount)<0) {  
                throw new RuntimeException();  
            } else {  
                fromAccount.debit(amount);  
                toAccount.credit(amount);  
            }  
        }  
    }  
}

当两个线程分别调用上面的代码，其中一个线程从X向Y转账，另一个线程从Y向X转账，那么就会发生死锁：

A: transferMoney(myAccount,yourAccount,10);

B: transferMoney(yourAccount,myAccount,10);

如果执行顺序不当，那么可能A获得myAccount的锁并等待yourAccount，B获得yourAccount的锁并等待myAccount

动态的锁顺序死锁还是由于获取锁的顺序不同导致的，为了解决这个问题，必须定义锁的顺序，并且整个程序都必须按照这个顺序来获取锁

public void transferMoney(final Account fromAccount, final Account toAccount, final DollarAmount amount) {  
        class Helper {  
            public void transfer() {  
                if (fromAccount.getBalance().compareTo(amount) < 0) {  
                    throw new RuntimeException();  
                } else {  
                    fromAccount.debit(amount);  
                    toAccount.credit(amount);  
                }  
            }  
        }  
       // 通过唯一hashcode来统一锁的顺序, 如果account具有唯一键, 可以采用该键来作为顺序.  
        int fromHash = System.identityHashCode(fromAccount);  
        int toHash = System.identityHashCode(toAccount);  
        if (fromHash < toHash) {  
            synchronized (fromAccount) {  
                synchronized (toAccount) {  
                    new Helper().transfer();  
                }  
            }  
        } else if (fromHash > toHash) {  
            synchronized (toAccount) {  
                synchronized (fromAccount) {  
                    new Helper().transfer();  
                }  
            }  
        } else {  
            synchronized (tieLock) { // 针对fromAccount和toAccount具有相同的hashcode  
                synchronized (fromAccount) {  
                    synchronized (toAccount) {  
                        new Helper().transfer();  
                    }  
                }  
            }  
        }  
    }