并发编程实战死锁读书笔记之吐槽

秒速五厘米 2022-06-11 02:54 234阅读 0赞

# 简单顺序死锁 #

package com.txr.TransferMoneyDemo;
    
    /**
     * Created by txr on 2017/7/28.
     */
    public class LeftRightDeadlock {
        private final Object left =new Object();
        private final Object right=new Object();
        public void leftRight(){
            synchronized (left){
                synchronized (right){
                    dosomething();
                }
            }
        }
        public void rigthLeft(){
            synchronized (right){
                synchronized (left){
                    dosomethingElse();
                }
            }
        }
    }

显然这样会出现死锁，比如A-->B   B--->A，这个时候第一个线程获得了锁A等待获取锁B，第二个线程线程获取了锁B等待获取锁A，这样就形成了死锁

# 动态的锁顺序死锁 #

package com.txr.TransferMoneyDemo;
    
    import javax.naming.InsufficientResourcesException;
    
    /**
     * Created by zj-db0236 on 2017/7/28.
     */
    public class LeftRightDeadlock {
        public void transferMoney(Account fromAcct,Account toAcct,DollarAmout amout) throws InsufficientResourcesException {
            synchronized (fromAcct){
                synchronized (toAcct){
                    if(fromAcct.getBalance().compareTo(amout)<0)
                        throw new InsufficientResourcesException();
                    else{
                        fromAcct.debit(amout);
                        toAcct.credit(amout);
                    }
                }
            }
        }
    }

这种死锁也很容易理解，比如 A--->B   另一个线程  B--->A

A:transferMoney(mycount ,yourAccount,1000)

B:transferMoney(yourcount ,myAccount,2000)

和上面一样会发生死锁

# 通过锁顺序来避免死锁 #

private static final Object tieLock =new Object();
    
        /**
         * 以顺序锁的形式来转钱，System.identityHashCode是个本地方法，
         * 是以引用地址来计算的，HashCode是以值来计算的
         * @param fromAcct 转账人
         * @param toAcct   被转账人
         * @param amout     钱
         * @throws InsufficientResourcesException
         */
        public static void transferMoney(final Account fromAcct,
                                  final Account toAcct, final DollarAmout amout) throws InsufficientResourcesException {
            class Helper{
                public void transfer() throws InsufficientResourcesException{
                        //转账人出账
                        fromAcct.debit(amout);
                        //被转账人入账
                        toAcct.credit(amout);
    
                }
            }
            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();
                        }
                    }
                }
            }
        }

# 以下来坑了，书上说如下代码典型情况下会发生死锁 #

public class IdentityHashCodeDemo {
        private static final int NUM_THREADS=20;
        private static final int NUM_ACCOUNTS=5;
        private static final int NUM_ITERATIONS=100000;
    
        /**
         * 模拟十万次转账居然会发生死锁这是为什么？
         * @param args
         */
        public static void main(String[] args) {
            final Random rnd=new Random();
            final Account[] accounts=new Account[NUM_ACCOUNTS];
    
            for (int i=0;i<accounts.length;i++)
                accounts[i]=new Account();
            //模拟十万次转账,不考虑账户为负数的情况
            class TransferThread extends Thread{
                @Override
                public void run() {
                    for(int i=0;i<NUM_ITERATIONS;i++){
    
                        int fromAcct=rnd.nextInt(NUM_ACCOUNTS);
                        int toAcct=rnd.nextInt(NUM_ACCOUNTS);
                        DollarAmout amout=new DollarAmout(rnd.nextInt(1000));
                        try {
                            //很纳闷明明用了顺序锁为什么还会很快出现死锁
                            transferMoney(accounts[fromAcct],accounts[toAcct],amout);
                        } catch (InsufficientResourcesException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
            for (int i=0;i<NUM_THREADS;i++)
                new TransferThread().start();
        }
    }

百思不得其解，最后没办法上网把源码当下来了，查看源码傻眼了，源码如是写着

package net.jcip.examples;
    
    import java.util.*;
    
    import net.jcip.examples.DynamicOrderDeadlock.Account;
    import net.jcip.examples.DynamicOrderDeadlock.DollarAmount;
    
    /**
     * DemonstrateDeadlock
     * <p/>
     * Driver loop that induces deadlock under typical conditions
     *
     * @author Brian Goetz and Tim Peierls
     */
    public class DemonstrateDeadlock {
        private static final int NUM_THREADS = 20;
        private static final int NUM_ACCOUNTS = 5;
        private static final int NUM_ITERATIONS = 1000000;
    
        public static void main(String[] args) {
            final Random rnd = new Random();
            final Account[] accounts = new Account[NUM_ACCOUNTS];
    
            for (int i = 0; i < accounts.length; i++)
                accounts[i] = new Account();
    
            class TransferThread extends Thread {
                public void run() {
                    for (int i = 0; i < NUM_ITERATIONS; i++) {
                        int fromAcct = rnd.nextInt(NUM_ACCOUNTS);
                        int toAcct = rnd.nextInt(NUM_ACCOUNTS);
                        DollarAmount amount = new DollarAmount(rnd.nextInt(1000));
                        try {
                            DynamicOrderDeadlock.transferMoney(accounts[fromAcct], accounts[toAcct], amount);
                        } catch (DynamicOrderDeadlock.InsufficientFundsException ignored) {
                        }
                    }
                }
            }
            for (int i = 0; i < NUM_THREADS; i++)
                new TransferThread().start();
        }
    }

看到了什么？担心你们粗心我给勾出来了

![Center][]

简直就苦笑不得，书上压根就没有提到这个类，他就默默的用了也不说，然后我们再来看看DynamicOrderDeadlock类

package net.jcip.examples;
    
    import java.util.concurrent.atomic.*;
    
    /**
     * DynamicOrderDeadlock
     * <p/>
     * Dynamic lock-ordering deadlock
     *
     * @author Brian Goetz and Tim Peierls
     */
    public class DynamicOrderDeadlock {
        // Warning: deadlock-prone!
        public static void transferMoney(Account fromAccount,
                                         Account toAccount,
                                         DollarAmount amount)
                throws InsufficientFundsException {
            synchronized (fromAccount) {
                synchronized (toAccount) {
                    if (fromAccount.getBalance().compareTo(amount) < 0)
                        throw new InsufficientFundsException();
                    else {
                        fromAccount.debit(amount);
                        toAccount.credit(amount);
                    }
                }
            }
        }
    
        static class DollarAmount implements Comparable<DollarAmount> {
            // Needs implementation
    
            public DollarAmount(int amount) {
            }
    
            public DollarAmount add(DollarAmount d) {
                return null;
            }
    
            public DollarAmount subtract(DollarAmount d) {
                return null;
            }
    
            public int compareTo(DollarAmount dollarAmount) {
                return 0;
            }
        }
    
        static class Account {
            private DollarAmount balance;
            private final int acctNo;
            private static final AtomicInteger sequence = new AtomicInteger();
    
            public Account() {
                acctNo = sequence.incrementAndGet();
            }
    
            void debit(DollarAmount d) {
                balance = balance.subtract(d);
            }
    
            void credit(DollarAmount d) {
                balance = balance.add(d);
            }
    
            DollarAmount getBalance() {
                return balance;
            }
    
            int getAcctNo() {
                return acctNo;
            }
        }
    
        static class InsufficientFundsException extends Exception {
        }
    }

是不是看完就很好理解为什么在大多数系统下会很快发生死锁了？好坑好坑好坑，一声不说就直接用了个错误的类，以上也说明在附有源码的时候，看书一定要对照源码看，这样能避免很多迷惑性的问题，写此博客也希望能帮到很多跟我一样有困惑的人【我百度，谷歌了很久始终没有找到有人写过这个】

[Center]: /images/20220611/720e96ff895d4c49b55547146ccdcec1.png