实际工程中避免死锁的技巧

1、设置超时超时时间

使用Lock锁中tryLock方法的超时放弃机制，在指定时间内获取不到锁就放弃原来占用的锁。破坏死锁的请求与保持条件。

/**
 * 描述：
 *      用tryLock来避免死锁
 */
public class TryLockDeadLock implements Runnable{

    int flag;
    static Lock lock1 = new ReentrantLock();
    static Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        TryLockDeadLock tryLockDeadLock1 = new TryLockDeadLock();
        TryLockDeadLock tryLockDeadLock2 = new TryLockDeadLock();
        tryLockDeadLock1.flag = 1;
        tryLockDeadLock2.flag = 0;
        new Thread(tryLockDeadLock1).start();
        new Thread(tryLockDeadLock2).start();
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (flag == 1) {
                try {
                    if (lock1.tryLock(800, TimeUnit.MILLISECONDS)) {
                        System.out.println("线程1成功获取到了锁1");
                        Thread.sleep((long) (Math.random()*1000)) ;
                        if (lock2.tryLock(800,TimeUnit.MILLISECONDS)) {
                            System.out.println("线程1成功获取到了两把锁");
                            lock1.unlock();
                            lock2.unlock();
                            break;
                        }else{
                            System.out.println("线程1获取锁2失败，已重试");
                            lock1.unlock();
                            Thread.sleep((long) (Math.random()*1000)) ;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if (flag == 0) {
                try {
                    if (lock2.tryLock(800, TimeUnit.MILLISECONDS)) {
                        System.out.println("线程2成功获取到了锁2");
                        Thread.sleep((long) (Math.random()*1000)) ;
                        if (lock1.tryLock(800,TimeUnit.MILLISECONDS)) {
                            System.out.println("线程2成功获取到了两把锁");
                            lock1.unlock();
                            lock2.unlock();
                            break;
                        }else{
                            lock2.unlock();
                            System.out.println("线程2获取锁1失败，已重试");
                            Thread.sleep((long) (Math.random()*1000)) ;
                        }
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

2、多使用并发类而不是自己设计锁

并发类已经经过了很多版本的迭代来证明它是可靠的，如果我们自己设计锁的话，还需要一个迭代的过程。比如下面的：

• ConcurrentHashMap、ConcurrentLinkedQueue、AtomicBoolean等
• 实际应用中java.util.concurrent.atomic十分有用，简单方便且效率比使用Lock更高
• 多用并发集合，少用同步集合（虽然也是安全的但是效率低），并发集合比同步集合的可拓展性更好（比如：并发场景需要用到map，首先想到用ConcurrentHashMap）

3、尽量降低锁的粒度

不仅能降低死锁的风险还能提高并发的效率

4、如果能使用同步代码块，就不要使用同步方法：自己指定锁对象

自己指定的锁对象能够更加灵活的进行控制。

5、给你的线程起一个有意义的名字

在前面的定位死锁的方法中（jstack、ThreadMXBean），我们可以看到定位到发生死锁的线程如果不起一个见名知意的名字的话，排查起来是非常困难的。

6、避免锁的嵌套

7、分配资源前先看看能不能收回来：银行家算法

8、尽量不要几个功能同用一把锁：专锁专用