java编程实战第十章笔记

第十章 避免活跃性危险

一 死锁

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

例如：当线程占有锁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();  
                    }  
                }  
            }  
        }  
    } 

二 死锁的避免与分析

1. 有界线程池/资源池与相互依赖的任务不能一起使用
2. 如果要获取多个锁，必须考虑锁的顺序，尽可能使用开放调用
3. 使用显示锁检测死锁，并且可以从死锁中恢复过来
4. 通过线程转储信息来分析死锁

三 其他活跃性危险

1. 饥饿：由于线程无法访问它所需要的资源而不能继续执行时，就发生了饥饿
2. 糟糕的响应性也很影响活跃性
3. 活锁：尽管没有被阻塞, 线程却仍然不能继续, 因为它不断重试相同的操作, 却总是失败. 活锁通常发生在消息处理应用程序中