Java中各种死锁详细讲述及其解决方案（图文并茂，浅显易懂）

package com.liziba.dl;
import java.math.BigDecimal;
/**
 * <p>
 * 转账类优化 -> 通过hash算法
 * </p>
 *
 * @Author: Liziba
 */
public class TransferMoneyOptimize {
    /** hash 冲突时使用第三个锁(优秀的hash算法冲突是很少的！) */
    private static final Object conflictShareLock = new Object();
    /**
     * 转账方法
     *
     * @param accountFrom       转账方
     * @param accountTo         接收方
     * @param amt               转账金额
     * @throws Exception
     */
    public static void transferMoney(Account accountFrom,
                                     Account accountTo,
                                     BigDecimal amt) throws Exception {
    // 计算hash值
        int accountFromHash = System.identityHashCode(accountFrom);
        int accountToHash = System.identityHashCode(accountTo);
    // 如下三个分支能一定控制账户之间的转是不会产生死锁的
        if (accountFromHash > accountToHash) {
            synchronized (accountFrom) {
                synchronized (accountTo) {
                    transferMoneyHandler(accountFrom, accountTo, amt);
                }
            }
        } else if (accountToHash > accountFromHash) {
            synchronized (accountTo) {
                synchronized (accountFrom) {
                    transferMoneyHandler(accountFrom, accountTo, amt);
                }
            }
        } else {
            // 解决hash冲突
            synchronized (conflictShareLock) {
                synchronized (accountFrom) {
                    synchronized (accountTo) {
                        transferMoneyHandler(accountFrom, accountTo, amt);
                    }
                }
            }
        }
    }
    /**
     * 账户金额增加处理
     *
     * @param accountFrom       转账方
     * @param accountTo         接收方
     * @param amt               转账金额
     * @throws Exception
     */
    private static void transferMoneyHandler(Account accountFrom,
                                             Account accountTo,
                                             BigDecimal amt) throws Exception {
        if (accountFrom.balance.compareTo(amt) < 0) {
            throw new Exception(accountFrom.number + " balance is not enough.");
        } else {
            accountFrom.setBalance(accountFrom.balance.subtract(amt));
            accountTo.setBalance(accountTo.balance.add(amt));
            System.out.println("Form" + accountFrom.number + ": " + accountFrom.balance.toPlainString()
                    +"\t" + "To" +  accountTo.number + ": " + accountTo.balance.toPlainString());
        }
    }
}

package com.liziba.dl;
import java.util.Objects;
/**
 * <p>
 *      出租车类
 * </p>
 *
 * @Author: Liziba
 */
public class Taxi {
    /** 出租车唯一标志 */
    private String id;
    /** 当前坐标 */
    private Coordinate location;
    /** 目的地坐标 */
    private Coordinate destination;
    /** 所属车队 */
    private final Fleet fleet;
    /**
     * 获取当前地址信息
     * @return
     */
    public synchronized Coordinate getLocation() {
        return location;
    }
    /**
     * 更新当前地址信息
     * 如果当前地址与目的地地址一致，则表名到达目的地需要通知车队，当前出租车空闲可用前往下一个目的地
     * 
     * @param location
     */
    public synchronized void setLocation(Coordinate location) {
        this.location = location;
        if (location.equals(destination)) {
            fleet.free(this);
        }
    }
    public Coordinate getDestination() {
        return destination;
    }
    /**
     * 设置目的地
     *
     * @param destination
     */
    public synchronized void setDestination(Coordinate destination) {
        this.destination = destination;
    }
    public Taxi(Fleet fleet) {
        this.fleet = fleet;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Taxi taxi = (Taxi) o;
        return Objects.equals(location, taxi.location) &&
                Objects.equals(destination, taxi.destination);
    }
    @Override
    public int hashCode() {
        return Objects.hash(location, destination);
    }
}

package com.liziba.dl;
import java.util.Set;
/**
 * <p>
 *      车队类 -> 调度管理出租车
 * </p>
 *
 * @Author: Liziba
 */
public class Fleet {
    /** 车队中所有出租车 */
    private final Set<Taxi> taxis;
    /** 车队中目前空闲的出租车 */
    private final Set<Taxi> available;
    public Fleet(Set<Taxi> taxis) {
        this.taxis = this.available = taxis;
    /**
     * 出租车到达目的地后调用该方法，向车队发出当前出租车空闲信息
     *
     * @param taxi
     */
    public synchronized void free(Taxi taxi) {
        available.add(taxi);
    }
    /**
     * 获取所有出租车在不同时刻的地址快照
     * @return
     */
    public synchronized Image getImage() {
        Image image = new Image();
        for (Taxi taxi : taxis) {
            image.drawMarker(taxi);
        }
        return image;
    }
}

package com.lizba.currency.deadlock;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
/**
 * <p>
 *      单线程Executor中任务发送死锁
 * </p>
 *
 * @Author: Liziba
 * @Date: 2021/7/1 21:25
 */
public class ThreadDeadLock {
    /** 单个线程的线程池 */
    static ExecutorService executorService = Executors.newSingleThreadExecutor();
    public static class Task1 implements Callable<String> {
        @Override
        public String call() throws Exception {
            Future<String> first = executorService.submit(new Task2());
            Future<String> second = executorService.submit(new Task2());
            // 当前任务等待子任务的结果，但是两个子任务在等待主任务完成，导致死锁
            return first.get() + second.get();
        }
    }
    public static class Task2 implements Callable<String> {
        @Override
        public String call() throws Exception {
            return "Hello Java";
        }
    }
    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        executorService.submit(new Task1());
    }
}