死锁

　　死锁发生在线程之间时，指两个线程各自持有的锁刚好是对方线程请求的，相互等待，系统阻塞。这种死锁往往是线程持有两个以上的锁，且以不同的顺序请求锁导致的，因此也叫锁顺序死锁。看例子：

package com.wulinfeng.concurrent;

import java.util.Random;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class DemonstrateDeadLock {
    private static final int NUM_THREADS = 20; // 起20个线程处理
    private static final int NUM_ACCOUNTS = 5; // 5个账户进行转账
    private static final int NUM_ITERATIONS = 100000; // 转个10万次

    public static void main(String[] args) {
        final DemonstrateDeadLock lock = new DemonstrateDeadLock();
        final Random r = new Random();
        final Account[] accounts = new Account[NUM_ACCOUNTS];

        for (int i = 0; i < accounts.length; i++) {
            int money = r.nextInt(100000);

            // 为了避免出现转出账户金额小于转账金额的情况，5个账户的初始资金必须1万到10万之间
            if (money < 10000) {
                money = 10000;
            }
            accounts[i] = lock.new Account(money);
        }

        class TransferThread extends Thread {
            public void run() {
                // 5个账户之间随机相互转账，每次转几块钱，每个线程转个10万次
                for (int i = 0; i < NUM_ITERATIONS; i++) {
                    int fromAcct = r.nextInt(NUM_ACCOUNTS);
                    int toAcct = r.nextInt(NUM_ACCOUNTS);

                    // 避免转给自己
                    if (fromAcct == toAcct) {
                        toAcct = NUM_ACCOUNTS - fromAcct - 1;
                    }
                    DollarAmount amount = lock.new DollarAmount(r.nextInt(10));
                    System.out.printf("第%d次：从账户%d到账户%d转%d元
", i, fromAcct, toAcct, amount.getAmount());
                    transferMoneyWithDeadLock(accounts[fromAcct], accounts[toAcct], amount);
                }
            }

            /**
             * 每次转账都会先锁转出账户A，再锁转入账户B，然后开始转账。因为被调用时参数顺序不可预测，因此锁顺序也不可预测
             * 如：并发，H线程是A账户->B账户，J线程是B账户->A账户，传参顺序和锁顺序也分别是A->B，B->A，
             * H线程持有A锁等待B锁，J线程持有B锁等待A锁，互相等待，死锁
             * 
             * @param fromAccount
             * @param toAccount
             * @param amount
             */
            public void transferMoneyWithDeadLock(Account fromAccount, Account toAccount, DollarAmount amount) {
                synchronized (fromAccount) {
                    synchronized (toAccount) {
                        if (fromAccount.getBalance().compareTo(amount) < 0) {
                            throw new IllegalAccessError("not enough money to transfer.");
                        } else {
                            fromAccount.debit(amount);
                            toAccount.credit(amount);
                        }
                    }
                }
            }

            private final Object tieLock = new Object();

            /**
             * 5个账户的hashCode值是唯一的，每次先锁住较小值的账户可以实现每次都按顺序锁
             * 如H线程是A账户->B账户，J线程是B账户->A账户，A的hashCode：1，B的hashCode:2
             * 因为hashCode上A<B,所以锁获取顺序H:A->B；J:A->B，两个线程以相同顺序获取锁，不会导致相互等待的情况
             * 
             * @param fromAcct
             * @param toAcct
             * @param amount
             */
            public void transferMoneyWithoutDeadLock(final Account fromAcct, final Account toAcct,
                    final DollarAmount amount) {
                class Helper {
                    public void transfer() {
                        if (fromAcct.getBalance().compareTo(amount) < 0) {
                            throw new IllegalAccessError("not enough money to transfer.");
                        } 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();
                            }
                        }
                    }
                }
            }

            public void transferMoneyWithLock(Account fromAcct, Account toAcct, DollarAmount amount) {
                long timeout = 100; // 转账超过100毫秒即超时
                long stopTime = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(timeout);
                while (true) {
                    if (fromAcct.lock.tryLock()) { // 转入账户获取到锁才进入下面逻辑处理，获取不到则退出
                        try {
                            if (toAcct.lock.tryLock()) { // 转出账户获取到锁才进入下面逻辑处理，获取不到则退出
                                try {
                                    if (fromAcct.getBalance().compareTo(amount) < 0) {
                                        throw new IllegalAccessError("not enough money to transfer.");
                                    } else {
                                        fromAcct.debit(amount);
                                        toAcct.credit(amount);
                                        return; // 转账成功，退出循坏
                                    }
                                } finally {
                                    toAcct.lock.unlock(); // 释放转出账户锁
                                }
                            }
                        } finally {
                            fromAcct.lock.unlock(); // 释放转出账户锁
                        }
                    }

                    // 走到这里，说明获取转入或者转出锁失败，若不超时则退出重入
                    if (System.nanoTime() < stopTime) {
                        return;
                    }

                    // 否则休眠随机时间，避免活锁
                    try {
                        Thread.sleep(r.nextLong());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }

        for (int i = 0; i < NUM_THREADS; i++) {
            new TransferThread().start();
        }
    }

    /**
     * 账户，提供转出、转入方法
     * 
     * @author Administrator
     *
     */
    class Account {
        private DollarAmount balance;

        private Lock lock;

        public Account(int account) {
            this.balance = new DollarAmount(account);
            this.lock = new ReentrantLock();
        }

        public DollarAmount getBalance() {
            return balance;
        }

        public void debit(DollarAmount amount) {
            this.balance.remove(amount);
        }

        public void credit(DollarAmount amount) {
            this.balance.add(amount);
        }
    }

    /**
     * 转账金额，提供加钱、减钱方法
     * 
     * @author Administrator
     *
     */
    class DollarAmount {
        private int amount;

        public DollarAmount(int amount) {
            this.amount = amount;
        }

        public int compareTo(DollarAmount amount2) {
            int result;
            if (this.amount > amount2.getAmount()) {
                result = 1;
            } else if (this.amount < amount2.getAmount()) {
                result = -1;
            } else {
                result = 0;
            }
            return result;
        }

        public int add(DollarAmount amount) {
            return this.amount += amount.getAmount();
        }

        public int remove(DollarAmount amount) {
            return this.amount -= amount.getAmount();
        }

        public int getAmount() {
            return amount;
        }
    }
}

　　解决死锁有两种方法，一是使用内置锁通过保证锁顺序一致，参见上面代码里的transferMoneyWithoutDeadLock方法；二是使用显式锁的tryLock进行重试（获取锁失败则退出而不是阻塞），参见上面的transferMoneyWithLock方法。

　　另一种比较隐蔽的锁顺序不一致的情况发生在对象的方法调用，见下面代码：

package com.wulinfeng.concurrent;

import java.util.HashSet;
import java.util.Set;

public class ObjectsDeadLock {
    private static final int NUM_THREADS = 20; // 起20个线程处理
    // 随机产生的字符串
    private static final String[] msgs = new String[] { "abc", "dfg", "hij", "lmn", "opq", "rst", "wlf", "xyz" };
    private static final int NUM_ITERATIONS = 100000; // 每个线程跑个10万次

    public static void main(String[] args) {
        final ObjectsDeadLock lock = new ObjectsDeadLock();

        final Dispatcher dispatcher = lock.new Dispatcher();
        final Taxi taxi = lock.new Taxi(dispatcher);

        class WorkThread extends Thread {
            public void run() {
                for (int i = 0; i < NUM_ITERATIONS; i++) {
                    taxi.setStrDead(msgs[i % msgs.length]);
                    dispatcher.getStrDead(i);
                }
            };
        }

        for (int i = 0; i < NUM_THREADS; i++) {
            new WorkThread().start();
        }
    }

    class Taxi {
        private String msg;
        private final Dispatcher dispatcher;

        public Taxi(Dispatcher dispatcher) {
            this.dispatcher = dispatcher;
        }

        public synchronized String getStr() {
            return msg;
        }

        /**
         * 该方法先给自己加锁，再调用Dispatcher对象的加锁方法notifyAvailable，加锁顺序Taxi->Dispatcher
         * 
         * @param msg
         */
        public synchronized void setStrDead(String msg) {
            if (msg.equals("wlf")) {
                this.msg = msg;
                dispatcher.notifyAvailable(this);
            }
        }

        /**
         * 只给自己加锁，调用其他对象方法不加锁：锁Taxi->释放Taxi->锁Dispatcher->释放Dispatcher
         * 
         * @param msg
         */
        public void setStrNotDead(String msg) {
            boolean available = false;
            synchronized (this) {
                if (msg.equals("wlf")) {
                    this.msg = msg;
                    available = true;
                }
            }
            if (available) {
                dispatcher.notifyAvailable(this);
            }

        }
    }

    class Dispatcher {
        private final Set<Taxi> availableTaxis;

        public Dispatcher() {
            availableTaxis = new HashSet<Taxi>();
        }

        public synchronized void notifyAvailable(Taxi taxi) {
            availableTaxis.add(taxi);
        }

        /**
         * 该方法里调用Taxi对象的加锁方法getStr，加锁顺序Dispatcher->Taxi
         */
        public synchronized void getStrDead(int count) {
            for (Taxi t : availableTaxis) {
                System.out.println(t.getStr() + ": " + count);
            }
            availableTaxis.clear(); // 清空集合，准备迎接下一个符合条件的对象
        }

        /**
         * 只给自己加锁，调用其他对象方法不加锁：锁Dispatcher->释放Dispatcher->锁Taxi->释放Taxi
         * 
         * @param count
         */
        public void getStrNotDead(int count) {
            Set<Taxi> copy;

            // 复制给当前线程读，不影响其他线程写，读写分离
            synchronized (this) {
                copy = new HashSet<Taxi>(availableTaxis);
            }
            for (Taxi t : copy) {
                System.out.println(t.getStr() + ": " + count);
            }

            // 读完清空
            synchronized (this) {
                availableTaxis.clear();
            }
        }
    }
}

　　这里无法改变线程里锁的顺序，因此只能减锁，就是在加锁方法A里调用另一个对象的加锁方法B时，缩小加锁的代码块，让加锁方法B逃离方法A的锁。run方法里改两行代码再跑一次，死锁不再出现：

            public void run() {
                for (int i = 0; i < NUM_ITERATIONS; i++) {
                    taxi.setStrNotDead(msgs[i % msgs.length]);
                    dispatcher.getStrNotDead(i);
                }
            };

　　死锁发生在线程池中时，指的是池里的某任务无限期的等待它所依赖的其他任务，这也叫线程饥饿死锁。看例子：

package com.wulinfeng.concurrent;

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

public class ThreadDeadlock {
    ExecutorService es = Executors.newSingleThreadExecutor();

    public class ReaderTask implements Callable<String> {
        Future<String> header;
        String body = "Hell, world!";
        String result = null;

        @Override
        public String call() throws Exception {
            // 单线程池提交子任务
            header = es.submit(new LoadFileTask("welcome!"));
            result = header.get() + "
" + body + "
";
            System.out.printf("result:
%s", result);
            return result;
        }
    }

    public class LoadFileTask implements Callable<String> {
        private String msg;

        public LoadFileTask(String msg) {
            this.msg = msg;
        }

        public String call() {
            try {
                Thread.sleep(1000); // 模拟文件下载，耗时1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return msg;
        }
    }

    public static void main(String[] args) {
        ThreadDeadlock t = new ThreadDeadlock();
        try {
            // 单线程池提交父任务
            Future<String> father = t.es.submit(t.new ReaderTask());
            // 获取父任务结果依赖子任务结果，线程池只允许一个线程执行，父等子执行，子等父让位
            System.out.printf("out:
%s", father.get());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            t.es.shutdown();
        }
    }
}

　　上面使用了单线程的线程池，也就是每次只能容纳一个线程做串行执行的线程池。父线程需要启动子线程获取结果才能返回，而子线程需要父线程执行结束才能启动，因此父线程和子线程互相无限等待。解决方式很简单，线程池需要允许容纳两个以上的线程就可避免线程饥饿，如把newSingleThreadExecutor改为newCachedThreadPool。