Java多线程开发中避免死锁的八种方法

原文链接：https://blog.csdn.net/qq_33229669/article/details/108552331?utm_medium=distribute.pc_feed.none-task-blog-personrec_tag-6.nonecase&depth_1-utm_source=distribute.pc_feed.none-task-blog-personrec_tag-6.nonecase&request_id=5f6435ebdfc5717f9a1d8903

1. 设置超时时间

使用JUC包中的Lock接口提供的tryLock方法.
该方法在获取锁的时候, 可以设置超时时间, 如果超过了这个时间还没拿到这把锁, 那么就可以做其他的事情, 而不是像synchronized如果没有拿到锁会一直等待下去.

boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

造成超时的原因有很多种:发生了死锁, 线程进入了死循环, 线程逻辑复杂执行慢.

到了超时时间, 那么就获取锁失败, 就可以做一些记录操作, 例如打印错误日志, 发送报警邮件,提示运维人员重启服务等等.

如下的代码演示了使用tryLock 来避免死锁的案例.
线程1 如果拿到了锁1 , 那么就在指定的800毫秒内去尝试拿到锁2, 如果两把锁都拿到了 , 那么就释放这两把锁. 如果在指定的时间内, 没有拿到锁2 , 那么就释放锁1 .

线程2 与线程1相反, 先去尝试拿到锁2, 如果拿到了, 就去在3s内尝试拿到锁1, 如果拿到了, 那么就释放锁1和2, 如果3s内没有拿到锁1, 那么释放锁2 .

package com.thread.deadlock;

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

/**
 * 类名称:TryLockDeadlock
 * 类描述:  使用lock接口提供的trylock 避免死锁
 *
 * @author: https://javaweixin6.blog.csdn.net/
 * 创建时间:2020/9/12 17:23
 * Version 1.0
 */
public class TryLockDeadlock implements Runnable {
    int flag = 1;

    //ReentrantLock 为可重入锁
    static Lock lock1 = new ReentrantLock();
    static Lock lock2 = new ReentrantLock();

    public static void main(String[] args) {
        // 创建两个线程 给出不同的flag  并启动
        TryLockDeadlock r1 = new TryLockDeadlock();
        TryLockDeadlock r2 = new TryLockDeadlock();

        r1.flag = 1 ;
        r2.flag = 0 ;
        new Thread(r1).start();
        new Thread(r2).start();

    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (flag == 1) {
                //先获取锁1  再获取锁2

                try {
                    //给锁1 800毫秒与获取锁, 如果拿到锁, 返回true, 反之返回false
                    if (lock1.tryLock(800, TimeUnit.MICROSECONDS)) {

                        System.out.println("线程1获取到了锁1  ");

                        //随机的休眠
                        Thread.sleep(new Random().nextInt(1000));

                        if (lock2.tryLock(800, TimeUnit.MICROSECONDS)) {

                            System.out.println("线程1获取到了锁2  ");
                            System.out.println(" 线程1 成功获取了两把锁   ");
                            //释放两把锁, 退出循环
                            lock2.unlock();
                            lock1.unlock();
                            break;
                        } else {
                            System.out.println(" 线程1尝试获取锁2 失败, 已经重试  ");

                            //释放锁1
                            lock1.unlock();

                            //随机的休眠
                            Thread.sleep(new Random().nextInt(1000));
                        }
                    } else {
                        System.out.println(" 线程1 获取锁1失败, 已重试  ");

                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            if (flag == 0) {

                //先获取锁2  再获取锁1. 并且尝试获取锁的时间变长 ,改成3s

                try {

                    //给锁1 800毫秒与获取锁, 如果拿到锁, 返回true, 反之返回false
                    if (lock2.tryLock(3000, TimeUnit.MICROSECONDS)) {

                        System.out.println("线程2获取到了锁2  ");

                        //随机的休眠
                        Thread.sleep(new Random().nextInt(1000));

                        if (lock1.tryLock(3000, TimeUnit.MICROSECONDS)) {
                            System.out.println("线程2获取到了锁1  ");
                            System.out.println(" 线程2 成功获取了两把锁   ");
                            //释放两把锁, 退出循环
                            lock1.unlock();
                            lock2.unlock();
                            break;
                        } else {
                            System.out.println(" 线程2尝试获取锁1 失败, 已经重试  ");

                            //释放锁2
                            lock2.unlock();

                            //随机的休眠
                            Thread.sleep(new Random().nextInt(1000));
                        }
                    } else {
                        System.out.println(" 线程2 获取锁2失败, 已重试  ");

                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

运行程序后, 此时打印的情况如下:
线程1和2 ,分别拿到了锁1 和2 . 如果此时是用synchronized加锁的, 那么就会进入死循环的情况 , 因为此时线程1是要去获取锁2的, 而此时锁2被线程2持有着 , 线程2此时要获取锁1 ,而锁1被线程2持有, 那么就会造成死锁.
而使用trylock后, 如下图打印, 线程1在尝试800ms获取锁2失败后, 释放了锁1, 那么此时锁2就获得了锁1, 线程2获得了两把锁, 释放了这两把锁, 接着线程1就获得了这两把锁.

再次运行程序, 此时程序打印如下 . 可以看到线程2两次获取锁1 失败 , 两次获得了CPU的执行权, 可能是由于线程1休眠时间过长导致的.
线程2重复2次失败获取锁1失败后, 线程1苏醒, 获得了2把锁, 并且释放了两把锁, 线程2之后也获得了2把锁.

2. 多使用JUC包提供的并发类,而不是自己设计锁

JDK1.5后, 有JUC包提供并发类, 而不需要自己用wait 和notify来进行线程间的通信操作 , 这些成熟的并发类已经考虑的场景很完备了, 比自己设计锁更加安全.
JUC中的并发类例如 ConcurrentHashMap ConcurrentLinkedQueue AtomicBoolean 等等
实际应用中java.util.concurrent.atomic 包中提供的类使用广泛, 简单方便, 并且效率比Lock更高.

多用并发集合, 而不是用同步集合.
例如用ConcurrentHashMap , 而不是使用下图中Collections工具类提供的同步集合. 因为同步集合性能低

3. 尽量降低锁的使用粒度

尽量降低锁的使用粒度 : 用不同的锁 ,而不是同一个锁.
整个类如果使用一个锁来保护的话, 那么效率会很低, 而且有死锁的风险, 很多线程都来用这把锁的话, 就容易造成死锁.
锁的使用范围, 只要能满足业务要求, 范围越小越好.

4. 尽量使用同步代码块而不是同步方法

如果能使用同步代码块, 就不要使用同步方法,
好处有两点 :

同步方法是把整个方法给加上锁给同步了, 范围较大,造成性能低下, 使用同步代码块范围小,性能高.
使用同步代码块, 可以自己指定锁的对象, 这样有了锁的控制权, 这样也能避免发生死锁

5. 给线程起有意义的名字

给线程起有意义的名字, 是便于在测试环境和生产环境排查bug和事故的时候快速定位问题.
一些开源的框架和JDK都遵循了给线程起名字的规范

6. 避免锁的嵌套

如下的文章<必然发生死锁>例子中的代码就是锁的嵌套. 拿一个锁, 接着再拿一个锁. 并且使用的还是sleep这种不会释放锁的方式, 即拿到一个锁之后,不会去释放锁.
那么如果获取锁的顺序相反了, 就会造成死锁的发生!
https://javaweixin6.blog.csdn.net/article/details/108460550