多线程与死锁

超、凢脫俗 2022-02-03 11:23 417阅读 0赞

### 多线程与死锁 ###

*  动态顺序锁死锁
 *  Jconsole 查看死锁
 *  固定锁顺序避免死锁
 *  协作锁之间发生死锁
 *  开放调用避免死锁
 *  RetreenLock锁超时解决死锁

Java多线程开发中，为了避免多个线程对同一份数据的操作，我们需要对我们的线程做加锁的操作，只要加锁，就必然存在锁竞争的问题，如果锁竞争的问题处理不当就会出现死锁问题。死锁会让程序一直卡住，程序不再往下执行。我们只能通过中止并重启的方式来让程序重新执行。

这是我们非常不愿意看到的一种现象，我们要尽可能避免死锁的情况发生！

造成死锁的原因可以概括成三句话：

*  当前线程拥有其他线程需要的资源
 *  当前线程等待其他线程已拥有的资源
 *  都不放弃自己拥有的资源

# 动态顺序锁死锁 #

动态顺序锁导致死锁是最常见的死锁，例如我们在2个线程对2个账户进行转账操作，我们需要先锁定汇账账户减钱，然后再锁定入款账户加钱，一般来讲这个逻辑顺序是没有问题的，但是如果这2个线程并发同时处理，就会产生死锁。

public class DeadLock { 
    
    
        public static void main(String[] args) { 
            Account accountA = new Account(1L,"A",10000L);
            Account accountB = new Account(1L,"B",10000L);
    
            Thread a = new Thread(()->{ 
                try { 
                    transferMoney(accountA,accountB,100L);
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            });
    
            Thread b = new Thread(()->{ 
                try { 
                    transferMoney(accountB,accountA,100L);
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            });
    
            a.start();
            b.start();
    
            while (true){ 
                try { 
                    Thread.sleep(1000);
                }catch (Exception e){ 
                    e.printStackTrace();
                }
            }
    
        }
    
        // 转账
        public static void transferMoney(Account fromAccount,
                                         Account toAccount,
                                         Long amount) throws Exception { 
            // 锁定汇账账户
            synchronized (fromAccount) { 
                System.out.println(Thread.currentThread().getName()+"获取账户"+fromAccount.getName()+"锁");
                // 锁定来账账户
                synchronized (toAccount) { 
                    System.out.println(Thread.currentThread().getName()+"获取账户"+toAccount.getName()+"锁");
                    // 判余额是否大于0
                    if (fromAccount.getAmount().compareTo(amount) < 0) { 
                        throw new Exception("No enough money");
                    } else { 
                        // 汇账账户减钱
                        fromAccount.debit(amount);
                        // 来账账户增钱
                        toAccount.credit(amount);
    
                        System.out.println(Thread.currentThread().getName()+"完成转账");
    
                    }
                }
            }
        }
    }
    
    @Data
    class Account{ 
    
        private Long id;
    
        private String name;
    
        private Long amount;
    
        public Account(){ }
    
        public Account(long id,String name, long amount){ 
            this.id = id;
            this.name = name;
            this.amount = amount;
        }
    
    
        public void debit(Long amount) { 
            this.amount -= amount;
        }
    
        public void credit(Long amount) { 
            this.amount += amount;
        }
    
    }

程序执行结果如下：

Thread-1获取账户B锁
    Thread-0获取账户A锁

我们会发现我们的转账一直无法完成交易，程序一直卡住，程序不再往下执行。即发生了死锁。

# Jconsole 查看死锁 #

Jconsole是JDK自带的图形化界面工具，使用JDK给我们的的工具JConsole，我们可以直接查看Java进程中出现的死锁。  
控制台输入jconsole启动图形化界面工具

jconsole

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9zdW1tZXIuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]  
选择连接我们的本地调试进程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9zdW1tZXIuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]  
选择线程栏，我们会看到我们的正在运存的测试代码的3个线程  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9zdW1tZXIuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]  
选择我们的线程，检测死锁  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9zdW1tZXIuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9zdW1tZXIuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]  
很明显看出，Thread-0需要的资源被Thread-1占用，Thread-0被阻塞。

# 固定锁顺序避免死锁 #

针对动态锁顺序导致的死锁，我们可以通过固定加锁的顺序来解决

public class FixedOrderDeadLock { 
    
        public static void main(String[] args) { 
            Account accountA = new Account(1L,"A",10000L);
            Account accountB = new Account(1L,"B",10000L);
    
            Thread a = new Thread(()->{ 
                try { 
                    transferMoney(accountA,accountB,100L);
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            });
    
            Thread b = new Thread(()->{ 
                try { 
                    transferMoney(accountB,accountA,100L);
                } catch (Exception e) { 
                    e.printStackTrace();
                }
            });
    
            a.start();
            b.start();
    
            while (true){ 
                try { 
                    Thread.sleep(1000);
                }catch (Exception e){ 
                    e.printStackTrace();
                }
            }
        }
    
        public static void transferMoney(final Account fromAcct,
                                  final Account toAcct,
                                  final Long amount)
                throws Exception { 
            class Helper { 
                public void transfer() throws Exception { 
                    if (fromAcct.getAmount().compareTo(amount) < 0)
                        throw new Exception("No enough money");
                    else { 
                        fromAcct.debit(amount);
                        toAcct.credit(amount);
    
                        System.out.println(Thread.currentThread().getName()+"完成转账");
                    }
                }
            }
            // 得到锁的hash值
            int fromHash = System.identityHashCode(fromAcct);
            int toHash = System.identityHashCode(toAcct);
    
            // 根据hash值来上锁 不管是汇款账户还是入款账户，总是Hash值小的先锁，则对象锁的顺序是固定的
            if (fromHash < toHash) { 
                synchronized (fromAcct) { 
                    System.out.println(Thread.currentThread().getName()+"获取账户"+fromAcct.getName()+"锁");
                    synchronized (toAcct) { 
                        System.out.println(Thread.currentThread().getName()+"获取账户"+toAcct.getName()+"锁");
                        new Helper().transfer();
                    }
                }
    
            } else if (fromHash > toHash) { // 根据hash值来上锁
                synchronized (toAcct) { 
                    System.out.println(Thread.currentThread().getName()+"获取账户"+toAcct.getName()+"锁");
                    synchronized (fromAcct) { 
                        System.out.println(Thread.currentThread().getName()+"获取账户"+fromAcct.getName()+"锁");
                        new Helper().transfer();
                    }
                }
            } else { //如果是同对象，由于 synchronized 已经支持可重入锁，所以并发的同账户互相转账不会产生死锁，锁顺序不产生影响
                synchronized (fromAcct) { 
                    synchronized (toAcct) { 
                        new Helper().transfer();
                    }
                }
            }
        }
    }

程序执行结果

Thread-0获取账户A锁
    Thread-0获取账户B锁
    Thread-0完成转账
    Thread-1获取账户A锁
    Thread-1获取账户B锁
    Thread-1完成转账

如结果所示，并不会产生死锁。

# 协作锁之间发生死锁 #

除了动态顺序锁发生死锁的情况，还存在一些死锁的情况，但是不是顺序锁那么简单可以被发现。因为有可能并不是在同一个方法中显示请求两个锁，而是嵌套另一个方法去获取第二个锁。这就是隐式获取两个锁(对象之间协作)。

例如，ProductProducer生产者会不断的生产商品并且向仓库注册商品，ProductDepository商品仓库会不断的处理注册到仓库的商品加工,生成编号。

public class CooperatingDeadlock {
    
        public static void main(String[] args) {
            ProductProducer productProducer = new ProductProducer();
            ProductDepository productDepository = new ProductDepository();
            productProducer.setProductDepository(productDepository);
    
            productProducer.start();
            productDepository.start();
    
            while (true){
                try {
                    Thread.sleep(1000);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }
    
    }
    
    class ProductProducer extends Thread{
    
        public void setProductDepository(ProductDepository productDepository) {
            this.productDepository = productDepository;
        }
    
        private ProductDepository productDepository;
    
        @Override
        public void run(){
            produce();
        }
    
        // produce()需要ProductProducer对象锁
        private synchronized void produce(){
            do {
                Product p = new Product(this);
                System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，生产商品，并向仓库注册");
                this.productDepository.addAvailable(p);
    
                try{
                    Thread.sleep(100);
                }catch (Exception e){
                    e.printStackTrace();
                }
            }while (true);
        }
    
        public synchronized void handle(Product product) {
            System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，加工商品,生成编号");
            product.setNo(System.currentTimeMillis());
        }
    }
    
    class ProductDepository extends Thread{
    
        public ProductDepository(){
            availableProductList = new ArrayList<>();
        }
    
        private ArrayList<Product> availableProductList;
    
        @Override
        public void run(){
            handleAvailable();
        }
    
        public synchronized void addAvailable(Product product) {
            System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，注册到仓库");
            availableProductList.add(product);
        }
    
        // handleAvailable()需要ProductDepository对象锁
        public synchronized void handleAvailable() {
            System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，将注册的商品进行加工");
            do{
                for (Product t : availableProductList)
                    // 调用handle()需要ProductProducer对象锁
                    t.handle();
    
                availableProductList.clear();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }while (true);
        }
    
    }
    
    class Product{
        private  ProductProducer productProducer;
    
        public Product(){}
    
        public void setNo(Long no) {
            this.no = no;
        }
    
        private Long no;
    
        public Product(ProductProducer productProducer){
            this.productProducer = productProducer;
        }
    
        public void handle(){
            this.productProducer.handle(this);
        }
    }

此时我们执行程序：

Thread-0获取com.pubutech.multithread.example.deadlock.ProductProducer对象锁，生产商品，并向仓库注册
    Thread-1获取com.pubutech.multithread.example.deadlock.ProductDepository对象锁，将注册的商品进行加工

很显然，我们的程序将陷入死锁无法继续执行下去。

# 开放调用避免死锁 #

在协作对象之间发生死锁的例子中，主要是因为在调用某个方法时就需要持有锁，并且在方法内部也调用了其他带锁的方法！

如果在调用某个方法时不再持有锁，而改为同步代码块仅用于保护那些涉及共享状态的操作！那么这种调用被称为开放调用！

我们可以这样来改造：

public class OpenMethodCooperationDeadLock { 
        public static void main(String[] args) { 
            OpenMethodProductProducer productProducer = new OpenMethodProductProducer();
            OpenMethodProductDepository productDepository = new OpenMethodProductDepository();
            productProducer.setProductDepository(productDepository);
    
            productProducer.start();
            productDepository.start();
    
            while (true){ 
                try { 
                    Thread.sleep(1000);
                }catch (Exception e){ 
                    e.printStackTrace();
                }
            }
        }
    
    }
    
    class OpenMethodProductProducer extends Thread{ 
    
        public void setProductDepository(OpenMethodProductDepository productDepository) { 
            this.productDepository = productDepository;
        }
    
        private OpenMethodProductDepository productDepository;
    
        @Override
        public void run(){ 
            produce();
        }
    
        private void produce(){ 
            do { 
                OpenMethodProduct p = null;
                //需要ProductProducer对象锁，但是缩小锁的范围，不会同时去获取两个锁
                synchronized (this){ 
                    System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，生产商品，并向仓库注册");
                    p = new OpenMethodProduct(this);
                }
    
                if (null != p){ 
                    System.out.println(Thread.currentThread().getName()+"向仓库注册");
                    this.productDepository.addAvailable(p);
                }
    
                try{ 
                    Thread.sleep(100);
                }catch (Exception e){ 
                    e.printStackTrace();
                }
            }while (true);
        }
    
        public synchronized void handle(OpenMethodProduct product) { 
            System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，加工商品,生成编号");
            product.setNo(System.currentTimeMillis());
        }
    }
    
    class OpenMethodProductDepository extends Thread{ 
    
        public OpenMethodProductDepository(){ 
            availableProductList = new ArrayList<>();
        }
    
        private ArrayList<OpenMethodProduct> availableProductList;
    
        @Override
        public void run(){ 
            handleAvailable();
        }
    
        public synchronized void addAvailable(OpenMethodProduct product) { 
            System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，注册到仓库");
            availableProductList.add(product);
        }
    
        public void handleAvailable() { 
            do{ 
                ArrayList<OpenMethodProduct> availableProductListCopy;
                //需要ProductDepository对象锁，但是缩小锁的范围，不会同时去获取两个锁
                synchronized (this){ 
                    System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，准备将注册的商品进行加工");
                    availableProductListCopy = new ArrayList<>(availableProductList);
                    availableProductList.clear();
                }
    
                for (OpenMethodProduct t : availableProductListCopy)
                    // 调用handle()需要ProductProducer对象锁
                    t.handle();
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
            }while (true);
        }
    
    }
    
    class OpenMethodProduct{ 
        private  OpenMethodProductProducer productProducer;
    
        public OpenMethodProduct(){ }
    
        public void setNo(Long no) { 
            this.no = no;
        }
    
        private Long no;
    
        public OpenMethodProduct(OpenMethodProductProducer productProducer){ 
            this.productProducer = productProducer;
        }
    
        public void handle(){ 
            this.productProducer.handle(this);
        }
    }

程序执行结果如下，将会不断的协作下去直至我们终端程序而不会产生死锁

Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
    Thread-0向仓库注册
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，加工商品,生成编号
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
    Thread-0向仓库注册
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
    Thread-0向仓库注册
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，加工商品,生成编号
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
    Thread-0向仓库注册
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，加工商品,生成编号
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，加工商品,生成编号
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
    Thread-0向仓库注册
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
    Thread-0向仓库注册
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
    Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，加工商品,生成编号
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
    Thread-0向仓库注册
    Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库

# RetreenLock锁超时解决死锁 #

synchronized 关键字的锁是由Java虚拟机实现的，它无法显示获取锁超时，但是Java5以后Java RetreenLock提供了tryLock()方法来实现获取锁超时，我们在获取锁时可以使用tryLock()方法。当等待超过时限的时候，tryLock()不会一直等待，而是返回错误信息。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9zdW1tZXIuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70]: /images/20220203/fd82cd53c8164876b0a04cb90b96d2f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9zdW1tZXIuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 1]: /images/20220203/20f880cd056441518de32d80f09c5aaf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9zdW1tZXIuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 2]: /images/20220203/9296066c6b9f4cc89db04e083c47664a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9zdW1tZXIuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 3]: /images/20220203/11be27a03163450594da38d4d4fabec6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9zdW1tZXIuYmxvZy5jc2RuLm5ldA_size_16_color_FFFFFF_t_70 4]: /images/20220203/6eb67a0411354809aa46b9ee7a959f7e.png