[Praxis der gleichzeitigen Java-Programmierung] Sperrsequenz-Deadlock

package cn.study.concurrency.ch10;

public class Account {
    private String staffAccount;    //账号
    private String passWord;    //密码
    private int balance; //账户余额
    
    public Account(int money) {
        this.balance = money;
    }
    
    public String getStaffAccount() {
        return staffAccount;
    }
    public void setStaffAccount(String staffAccount) {
        this.staffAccount = staffAccount;
    }
    public String getPassWord() {
        return passWord;
    }
    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
    
    public void debit(int amount)
    {
        System.out.println("转出账户：" + amount);
    }
    
    public void credit(int amount)
    {
        System.out.println("转入账户：" + amount);
    }
    public int getBalance() {
        return balance;
    }
    public void setBalance(int balance) {
        this.balance = balance;
    }
    
}

package cn.study.concurrency.ch10;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import javax.naming.InsufficientResourcesException;

/**
 * 通过制定确定的锁顺序来避免死锁
 * @author xiaof
 *
 */
public class DeathLock {
    public void transferMoney(Account fromAccount, Account toAccount, int amount) throws InsufficientResourcesException
    {
        synchronized(fromAccount)
        {
            synchronized(toAccount)
            {
                //按参数的顺序上锁，这个依据参数的调用方法的顺序
                if(fromAccount.getBalance() < amount)
                {
                    //账户余额不足，无法转账
                    throw new InsufficientResourcesException();
                }
                else
                {
                    fromAccount.debit(amount);
                    toAccount.credit(amount);
                }
            }
        }
    }
    /**
     * 这个用来在无法判定枷锁顺序的时候的加时赛锁
     */
    private static final Object tieLock = new Object();
    
    public static void transferMoney2(final Account fromAccount, final Account toAccount, final int amount) throws InsufficientResourcesException
    {
        /**
         * 辅助内部类
         * @author xiaof
         *
         */
        class Helper
        {
            public void transfer() throws InsufficientResourcesException
            {
                //内部类可以随意访问外部类成员
                //按参数的顺序上锁，这个依据参数的调用方法的顺序
                if(fromAccount.getBalance() < amount)
                {
                    //账户余额不足，无法转账
                    throw new InsufficientResourcesException();
                }
                else
                {
                    fromAccount.debit(amount);
                    toAccount.credit(amount);
                }
            }
        }
        //返回给定对象的哈希码，该代码与默认的方法 hashCode() 返回的代码一样，无论给定对象的类是否重写 hashCode()
        int fromHash = System.identityHashCode(fromAccount);
        int toHash = System.identityHashCode(toAccount);
        //根据hash值判定加锁顺序，那么一样的对象的锁顺序就一定一样
        if(fromHash < toHash)
        {
            synchronized(fromAccount)
            {
                synchronized(toAccount)
                {
                    new Helper().transfer();
                }
            }
        }
        else if(toHash < fromHash)
        {
            synchronized(toAccount)
            {
                synchronized(fromAccount)
                {
                    new Helper().transfer();
                }
            }
        }
        else
        {
            //如果很不巧，hash值是一样的，那么就需要一个加时赛的机制，先获取外部锁，然后再此基础上对两个对象随机上锁
            synchronized(tieLock)
            {
                synchronized(fromAccount)
                {
                    synchronized(toAccount)
                    {
                        new Helper().transfer();
                    }
                }
            }
        }
        
    }
    
    static Account account1 = new Account(999);
    static Account account2 = new Account(999);
    
    public static void main(String[] args) throws InsufficientResourcesException {
        //对于第一个方法很容易死锁
        //比如：当有两个同时执行这个方法的调用时候
//        DeathLock dl = new DeathLock();
        //这个时候第一个调用在锁了account1，然后第二个调用锁了account2
        //同时第一个需要account2，第二个需要account1，这就发生竞争死锁了
//        dl.transferMoney(account1, account2, 998);
//        dl.transferMoney(account2, account1, 998);
//        
//        dl.transferMoney2(account1, account2, 998);
        ExecutorService pool = Executors.newFixedThreadPool(10);
        for(int i = 0; i < 5; ++ i)
        {
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        DeathLock.transferMoney2(account1, account2, 998);
                    } catch (InsufficientResourcesException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        
        for(int i = 0; i < 5; ++ i)
        {
            pool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        DeathLock.transferMoney2(account2, account1, 998);
                    } catch (InsufficientResourcesException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        
        pool.shutdown();
    }
}