简介
java中为了保障共享数据的安全性，咱们引入了锁的机制。有了锁就有可能产生死锁。
死锁的起因就是多个线程锁住了对方所须要的资源，而后现有的资源又没有开释，从而导致循环期待的状况。
通常来说如果不同的线程对加锁和开释锁的程序不统一的话，就很有可能产生死锁。
不同的加锁程序
咱们来看一个不同加锁程序的例子：
public class DiffLockOrder { private int amount; public DiffLockOrder(int amount){ this.amount=amount; } public void transfer(DiffLockOrder target,int transferAmount){ synchronized (this){ synchronized (target){ if(amount< transferAmount){ System.out.println("余额有余！"); }else{ amount=amount-transferAmount; target.amount=target.amount+transferAmount; } } } }}下面的例子中，咱们模仿一个转账的过程，amount用来示意用户余额。transfer用来将以后账号的一部分金额转移到指标对象中。
为了保障在transfer的过程中，两个账户不被他人批改，咱们应用了两个synchronized关键字，别离把transfer对象和指标对象进行锁定。
看起来如同没问题，然而咱们没有思考在调用的过程中，transfer的程序是能够发送变动的：
DiffLockOrder account1 = new DiffLockOrder(1000); DiffLockOrder account2 = new DiffLockOrder(500); Runnable target1= ()->account1.transfer(account2,200); Runnable target2= ()->account2.transfer(account1,100); new Thread(target1).start(); new Thread(target2).start();下面的例子中，咱们定义了两个account，而后两个账户相互转账，最初很有可能导致相互锁定，最初产生死锁。
应用private类变量
应用两个sync会有程序的问题，那么有没有方法只是用一个sync就能够在所有的实例中同步呢？
有的，咱们能够应用private的类变量，因为类变量是在所有实例中共享的，这样一次sync就够了：
public class LockWithPrivateStatic { private int amount; private static final Object lock = new Object(); public LockWithPrivateStatic(int amount){ this.amount=amount; } public void transfer(LockWithPrivateStatic target, int transferAmount){ synchronized (lock) { if (amount < transferAmount) { System.out.println("余额有余！"); } else { amount = amount - transferAmount; target.amount = target.amount + transferAmount; } } }}应用雷同的Order
咱们产生死锁的起因是无法控制上锁的程序，如果咱们可能管制上锁的程序，是不是就不会产生死锁了呢？
带着这个思路，咱们给对象再加上一个id字段：
private final long id; // 惟一ID，用来排序 private static final AtomicLong nextID = new AtomicLong(0); // 用来生成ID public DiffLockWithOrder(int amount){ this.amount=amount; this.id = nextID.getAndIncrement(); }在初始化对象的时候，咱们应用static的AtomicLong类来为每个对象生成惟一的ID。
在做transfer的时候，咱们先比拟两个对象的ID大小，而后依据ID进行排序，最初装置程序进行加锁。这样就可能保障程序，从而防止死锁。
public void transfer(DiffLockWithOrder target, int transferAmount){ DiffLockWithOrder fist, second; if (compareTo(target) < 0) { fist = this; second = target; } else { fist = target; second = this; } synchronized (fist){ synchronized (second){ if(amount< transferAmount){ System.out.println("余额有余！"); }else{ amount=amount-transferAmount; target.amount=target.amount+transferAmount; } } } }开释掉已占有的锁
死锁是相互申请对方占用的锁，然而对方的锁始终没有开释，咱们考虑一下，如果获取不到锁的时候，主动开释已占用的锁是不是也能够解决死锁的问题呢？
因为ReentrantLock有一个tryLock()办法，咱们能够应用这个办法来判断是否可能获取到锁，获取不到就开释已占有的锁。
咱们应用ReentrantLock来实现这个例子：
public class DiffLockWithReentrantLock { private int amount; private final Lock lock = new ReentrantLock(); public DiffLockWithReentrantLock(int amount){ this.amount=amount; } private void transfer(DiffLockWithReentrantLock target, int transferAmount) throws InterruptedException { while (true) { if (this.lock.tryLock()) { try { if (target.lock.tryLock()) { try { if(amount< transferAmount){ System.out.println("余额有余！"); }else{ amount=amount-transferAmount; target.amount=target.amount+transferAmount; } break; } finally { target.lock.unlock(); } } } finally { this.lock.unlock(); } } //随机sleep肯定的工夫，保障能够开释掉锁 Thread.sleep(1000+new Random(1000L).nextInt(1000)); } }}咱们把两个tryLock办法在while循环中，如果不能获取到锁就循环遍历。
本文的代码：
learn-java-base-9-to-20/tree/master/security
本文已收录于 http://www.flydean.com/java-security-code-line-dead-lock/最艰深的解读，最粗浅的干货，最简洁的教程，泛滥你不晓得的小技巧等你来发现！
欢送关注我的公众号:「程序那些事」,懂技术，更懂你！