关于java:java并发系列之死锁

34次阅读

共计 6367 个字符，预计需要花费 16 分钟才能阅读完成。

前言

在本文中，咱们将探讨死锁的概念及其产生的起因，并通过示例代码来阐明死锁的呈现状况。咱们还将介绍如何通过毁坏死锁的不同条件来解决死锁问题，通过深刻理解死锁及其解决办法，咱们能够更好地应答并解决零碎中可能呈现的死锁状况。

1. 死锁的概念与产生死锁的条件

死锁指的是，一组相互竞争资源的线程，它们之间 互相期待 而导致 永恒阻塞 的景象。
当上面四个条件 同时满足 时，就会产生死锁:

1.互斥：一个共享资源同一时间只能被一个线程占用；

2.占有且期待：线程 1 曾经取得共享资源 X，在期待获取共享资源 Y 的时候，它不会开释曾经占有的共享资源 X；

3.不可抢占：线程不能抢占其它线程曾经占有的共享资源；

4.循环期待：线程 1 期待线程 2 占有的资源，线程 2 期待线程 1 占有的资源，这就是循环期待。

2. 死锁示例及解决方案

呈现死锁时，只须要毁坏四个条件中的任意一个即可。然而，互斥条件是不能毁坏的，因为只有互斥能力解决线程平安问题，所以只须要毁坏其它三个条件中的任意一个即可。

2.1 死锁示例

以下代码模仿了两个人互相转账的场景。转账操作须要依照肯定的程序对账户进行加锁，以确保转账过程的安全性。然而，因为两个线程转账方向不同，导致加锁的程序也不同。最终，两个线程互相期待对方开释锁资源，导致呈现死锁景象。

账户类代码：

// 账户类
@Data
public class Account {
    private String accountName; // 账户名
    private int balance; // 账户余额

    public Account(String accountName, int balance) {
        this.accountName = accountName;
        this.balance = balance;
    }

    // 转出操作，缩小转出方的余额
    public void debit(int count) {this.balance -= count;}

    // 转入操作，减少转入方的余额
    public void credit(int count) {this.balance += count;}
}

转账示例代码：

// 呈现死锁的示例
public class TransferAccount implements Runnable {
    private Account formAccount; // 转出账户
    private Account toAccount; // 转入账户
    private int amount; // 转账金额

    public TransferAccount(Account formAccount, Account toAccount, int amount) {
        this.formAccount = formAccount;
        this.toAccount = toAccount;
        this.amount = amount;
    }

    @Override
    public void run() {while(true) {
            // 爱护转入转出账户，其余线程在转账期间无奈操作，保障线程平安
            synchronized (formAccount) {synchronized (toAccount) {
                    // 转出方余额足够
                    if (formAccount.getBalance() >= amount) {formAccount.debit(amount);
                        toAccount.credit(amount);
                    }
                }
            }
            System.out.println("fromAccount:" + formAccount.getAccountName() + ":" + formAccount.getBalance());
            System.out.println("toAccount:" + toAccount.getAccountName() + ":" + toAccount.getBalance());
        }
    }

    public static void main(String[] args) {Account zhangsan = new Account("张三", 1000);
        Account lisi = new Account("李四", 2000);

        // 因为上面持有锁的程序是相同的，所以可能会呈现持有并期待的状况而导致死锁
        // 张三向李四转 10 块钱
        Thread t1 = new Thread(new TransferAccount(zhangsan, lisi, 10));
        // 李四向张三转 20 块钱
        Thread t2 = new Thread(new TransferAccount(lisi, zhangsan, 20));

        t1.start();
        t2.start();}
}

2.2 解决方案一：毁坏占有且期待条件

如果在进行操作之前，一次性获取所有的共享资源 ，那么就不会存在占有局部资源，期待另一部分资源开释的状况了， 毁坏 的是 占有且期待条件。这种形式相当于把锁的范畴扩充了，尽管能解决死锁问题，然而会导致性能升高。

咱们定义一个资源管理器，应用一个汇合对立治理共享资源来实现上述操作。资源管理器中定义一个互斥的资源申请办法，只有所有资源都没被占用的状况下，能力同时获取所有资源。

// 一次性获取资源的资源管理器，解决死锁的持有并期待问题
public class Allocator {private List<Object> list = new ArrayList<>(); // 通过汇合对立治理申请的资源

    // 一次性申请所有资源
    synchronized boolean apply(Object form, Object to) {
        // 如果任意一个资源被占用了，就无奈一次性获取全副资源，返回 false
        if (list.contains(form) || list.contains(to)) {return false;}
        list.add(form);
        list.add(to);
        return true;
    }

    // 开释资源
    synchronized void free(Object form, Object to) {list.remove(form);
        list.remove(to);
    }
}

在转账操作中，先通过资源管理器获取资源，获取胜利的状况下才执行转账操作。转账操作执行结束后，开释资源。

// 通过 Allocator 对立申请资源
public class TransferAccount01 implements Runnable {
    private Account formAccount; // 转出账户
    private Account toAccount; // 转入账户
    private int count; // 转入金额
    private Allocator allocator; // 对立资源管理器

    public TransferAccount01(Account formAccount, Account toAccount, int count, Allocator allocator) {
        this.formAccount = formAccount;
        this.toAccount = toAccount;
        this.count = count;
        this.allocator = allocator;
    }

    @Override
    public void run() {while (true) {
            // 一次性申请所有资源
            if (allocator.apply(formAccount, toAccount)) {
                try {if (formAccount.getBalance() >= count) {formAccount.debit(count);
                        toAccount.credit(count);
                    }
                } finally {
                    // 开释资源
                    allocator.free(formAccount, toAccount);
                }
            }

            System.out.println("fromAccount:" + formAccount.getAccountName() + ":" + formAccount.getBalance());
            System.out.println("toAccount:" + toAccount.getAccountName() + ":" + toAccount.getBalance());
        }
    }

    public static void main(String[] args) {Account zhangsan = new Account("张三", 1000);
        Account lisi = new Account("李四", 2000);

        Allocator allocator = new Allocator();

        // 因为上面持有锁的程序是相同的，所以可能会呈现持有并期待的状况
        // 张三向李四转 10 块钱
        Thread t1 = new Thread(new TransferAccount01(zhangsan, lisi, 10, allocator));
        // 李四向张三转 20 块钱
        Thread t2 = new Thread(new TransferAccount01(lisi, zhangsan, 20, allocator));
        t1.start();
        t2.start();}
}

2.3 解决方案二：毁坏不可抢占条件

在后面死锁的代码示例里，加锁形式用的是 synchronized，如果线程获取不到锁，就会始终阻塞在那里。咱们是否让线程在获取其它锁失败的状况下，被动开释本人持有的锁，从而解决死锁呢？

咱们能够通过非阻塞的 ReentrantLock 的 tryLock()办法获取锁，如果没有获取到锁，它会立刻返回，而不是阻塞线程。获取不到其它锁，那就调用 ReentrantLock 的 unlock()办法来开释本人持有的锁，从而 毁坏不可抢占条件。

// 毁坏不可抢占条件
public class TransferAccount02 implements Runnable {
    private Account formAccount; // 转出账户
    private Account toAccount; // 转入账户
    private int count; // 转入金额
    ReentrantLock formLock = new ReentrantLock();
    ReentrantLock toLock = new ReentrantLock();

    public TransferAccount02(Account formAccount, Account toAccount, int count) {
        this.formAccount = formAccount;
        this.toAccount = toAccount;
        this.count = count;
    }

    @Override
    public void run() {while(true) {
            // 非阻塞期待，没有取得锁就不会进入上面这段代码
            if (formLock.tryLock()) {
                try {
                    // 假如获取了下面的锁，然而上面的锁没获取到
                    if (toLock.tryLock()) {
                        try {
                            // 转出方余额足够
                            if (formAccount.getBalance() >= count) {formAccount.debit(count);
                                toAccount.credit(count);
                            }
                        } finally {toLock.unlock(); // 开释 toLock 锁
                        }
                    }
                } finally {formLock.unlock(); // 获取 toLock 失败时，开释持有的 formLock
                }
            }
            System.out.println("fromAccount:" + formAccount.getAccountName() + ":" + formAccount.getBalance());
            System.out.println("toAccount:" + toAccount.getAccountName() + ":" + toAccount.getBalance());
        }
    }

    public static void main(String[] args) {Account zhangsan = new Account("张三", 1000);
        Account lisi = new Account("李四", 2000);

        // 张三向李四转 10 块钱
        Thread t1 = new Thread(new TransferAccount02(zhangsan, lisi, 10));
        // 李四向张三转 20 块钱
        Thread t2 = new Thread(new TransferAccount02(lisi, zhangsan, 20));
        
        t1.start();
        t2.start();}
}

2.4 解决方案三：毁坏循环期待条件

下面死锁案例中，导致死锁的根本原因是因为多线程加锁的程序不统一。如果张三和李四都遵循 雷同的加锁和解锁程序 ，就能够 毁坏循环期待条件 ，从而解决死锁问题。
在本实例中，按雷同的程序加锁解锁会毁坏原有的业务逻辑，这里仅仅是演示解决死锁的一种思路。在实在业务场景中，须要结合实际状况进行判断和取舍。

// 毁坏循环期待条件
public class TransferAccount03 implements Runnable {
    private Account formAccount; // 转出账户
    private Account toAccount; // 转入账户
    private int count; // 转入金额

    public TransferAccount03(Account formAccount, Account toAccount, int count) {
        this.formAccount = formAccount;
        this.toAccount = toAccount;
        this.count = count;
    }

    @Override
    public void run() {
        // 不论内部调用程序如何，外部保障加锁程序统一
        // 顺序调用的时候可能不走这段逻辑，然而逆序调用的时候会走这段逻辑，保障程序和逆序调用时候的加锁程序统一
        Account left = null;
        Account right = null;
        if (formAccount.hashCode() > toAccount.hashCode()) {
            left = toAccount;
            right = formAccount;
        }

        while(true) {
            // 爱护转入转出账户，其余线程在转账期间无奈操作
            synchronized (left) {synchronized (right) {
                    // 转出方余额足够
                    if (formAccount.getBalance() >= count) {formAccount.debit(count);
                        toAccount.credit(count);
                    }
                }
            }
            System.out.println("fromAccount:" + formAccount.getAccountName() + ":" + formAccount.getBalance());
            System.out.println("toAccount:" + toAccount.getAccountName() + ":" + toAccount.getBalance());
        }
    }

    public static void main(String[] args) {Account zhangsan = new Account("张三", 1000);
        Account lisi = new Account("李四", 2000);

        // 张三向李四转 10 块钱
        Thread t1 = new Thread(new TransferAccount03(zhangsan, lisi, 10));
        // 李四向张三转 20 块钱
        Thread t2 = new Thread(new TransferAccount03(lisi, zhangsan, 20));
        
        t1.start();
        t2.start();}
}

3. 总结

本文简略形容了死锁的概念、产生死锁须要满足的四个条件、毁坏死锁不同条件的思路和示例。在实战中如何预防死锁、排查死锁，将在前面的文章中补充。若文章中有形容不清或者有误的中央，欢送评论区探讨与斧正！

正文完
java
发表至： java
2023-05-20
 0
关于java:换行格式的Base64转换报错-Illegal-base64-character-a
关于java:Java8新特征之Lambda
关于java:JTday15
关于java:Java开发工程师进阶篇Java8的Stream流使用技巧