实际工作中避免死锁的方法

左手的ㄟ右手 2022-12-29 12:34 125阅读 0赞

1.设置超时时间

Lock的tryLock(Long timeout,TimeUnit unit) 设置获取锁的时间，如果达到这个时间还没有获取到锁，就回退
    synchronized 不具备尝试锁的能力
    获取不到锁的，也就是获取失败，我们进行日志记录，邮件提醒，重启服务器

/**
     * 用tryLock来避免死锁
     */
    public class TryLockDeadlock implements Runnable{
        int flag = 1;
        static Lock lock1 = new ReentrantLock();
        static Lock lock2 = new ReentrantLock();
    
        public static void main(String[] args) {
            TryLockDeadlock deadlock1 = new TryLockDeadlock();
            TryLockDeadlock deadlock2 = new TryLockDeadlock();
            deadlock1.flag = 1;
            deadlock1.flag = 0;
            new Thread(deadlock1).start();
            new Thread(deadlock2).start();
        }
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if(flag == 1){
                    try {
                        if(lock1.tryLock(300, TimeUnit.MILLISECONDS)){
                            System.out.println("线程1获取到了锁1");
                            Thread.sleep(new Random().nextInt(10));
                            if(lock2.tryLock(300, TimeUnit.MILLISECONDS)){
                                System.out.println("线程1获取到了锁2");
                                lock1.unlock();
                                lock2.unlock();
                                break;
                            }else{
                                System.out.println("线程1获取第二把锁的时候，失败，已经重试");
                                lock1.unlock();
                                Thread.sleep(new Random().nextInt(10));
                            }
                        }else{
                            System.out.println("线程1获取锁1失败，已经重试");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if(flag == 0){
                    try {
                        if(lock2.tryLock(3000, TimeUnit.MILLISECONDS)){
                            System.out.println("线程2获取到了锁2");
                            Thread.sleep(new Random().nextInt(1000));
                            if(lock1.tryLock(3000, TimeUnit.MILLISECONDS)){
                                System.out.println("线程2获取到了锁1");
                                lock2.unlock();
                                lock1.unlock();
                                break;
                            }else{
                                System.out.println("线程2获取第1把锁的时候，失败，已经重试");
                                lock2.unlock();
                                Thread.sleep(new Random().nextInt(1000));
                            }
                        }else{
                            System.out.println("线程2获取锁2失败，已经重试");
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

2.多使用并发类不要使用自己设计的锁

ConcurrentHashMap(并发场景，并需要map优先选择)、ConcurrentLinkedQueue、AtomicBoolean等

3.尽量降低锁的使用粒度：用不同的锁而不是一个锁

4.能使用同步代码块，就不适用同步方法：自己指定锁对象

5.给自己定义的线程起一个有意义的名称：排错方便

6.避免锁的嵌套

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

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