多线程与死锁

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

多线程与死锁

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

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

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

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

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

动态顺序锁死锁

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

  1. public class DeadLock { 
  4.     public static void main(String[] args) { 
  5.         Account accountA = new Account(1L,"A",10000L);
  6.         Account accountB = new Account(1L,"B",10000L);
  8.         Thread a = new Thread(()->{ 
  9.             try { 
  10.                 transferMoney(accountA,accountB,100L);
  11.             } catch (Exception e) { 
  12.                 e.printStackTrace();
  13.             }
  14.         });
  16.         Thread b = new Thread(()->{ 
  17.             try { 
  18.                 transferMoney(accountB,accountA,100L);
  19.             } catch (Exception e) { 
  20.                 e.printStackTrace();
  21.             }
  22.         });
  24.         a.start();
  25.         b.start();
  27.         while (true){ 
  28.             try { 
  29.                 Thread.sleep(1000);
  30.             }catch (Exception e){ 
  31.                 e.printStackTrace();
  32.             }
  33.         }
  35.     }
  37.     // 转账
  38.     public static void transferMoney(Account fromAccount,
  39.                                      Account toAccount,
  40.                                      Long amount) throws Exception { 
  41.         // 锁定汇账账户
  42.         synchronized (fromAccount) { 
  43.             System.out.println(Thread.currentThread().getName()+"获取账户"+fromAccount.getName()+"锁");
  44.             // 锁定来账账户
  45.             synchronized (toAccount) { 
  46.                 System.out.println(Thread.currentThread().getName()+"获取账户"+toAccount.getName()+"锁");
  47.                 // 判余额是否大于0
  48.                 if (fromAccount.getAmount().compareTo(amount) < 0) { 
  49.                     throw new Exception("No enough money");
  50.                 } else { 
  51.                     // 汇账账户减钱
  52.                     fromAccount.debit(amount);
  53.                     // 来账账户增钱
  54.                     toAccount.credit(amount);
  56.                     System.out.println(Thread.currentThread().getName()+"完成转账");
  58.                 }
  59.             }
  60.         }
  61.     }
  62. }
  64. @Data
  65. class Account{ 
  67.     private Long id;
  69.     private String name;
  71.     private Long amount;
  73.     public Account(){ }
  75.     public Account(long id,String name, long amount){ 
  76.         this.id = id;
  77.         this.name = name;
  78.         this.amount = amount;
  79.     }
  82.     public void debit(Long amount) { 
  83.         this.amount -= amount;
  84.     }
  86.     public void credit(Long amount) { 
  87.         this.amount += amount;
  88.     }
  90. }

程序执行结果如下：

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

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

Jconsole 查看死锁

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

  1. jconsole

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

固定锁顺序避免死锁

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

  1. public class FixedOrderDeadLock { 
  3.     public static void main(String[] args) { 
  4.         Account accountA = new Account(1L,"A",10000L);
  5.         Account accountB = new Account(1L,"B",10000L);
  7.         Thread a = new Thread(()->{ 
  8.             try { 
  9.                 transferMoney(accountA,accountB,100L);
  10.             } catch (Exception e) { 
  11.                 e.printStackTrace();
  12.             }
  13.         });
  15.         Thread b = new Thread(()->{ 
  16.             try { 
  17.                 transferMoney(accountB,accountA,100L);
  18.             } catch (Exception e) { 
  19.                 e.printStackTrace();
  20.             }
  21.         });
  23.         a.start();
  24.         b.start();
  26.         while (true){ 
  27.             try { 
  28.                 Thread.sleep(1000);
  29.             }catch (Exception e){ 
  30.                 e.printStackTrace();
  31.             }
  32.         }
  33.     }
  35.     public static void transferMoney(final Account fromAcct,
  36.                               final Account toAcct,
  37.                               final Long amount)
  38.             throws Exception { 
  39.         class Helper { 
  40.             public void transfer() throws Exception { 
  41.                 if (fromAcct.getAmount().compareTo(amount) < 0)
  42.                     throw new Exception("No enough money");
  43.                 else { 
  44.                     fromAcct.debit(amount);
  45.                     toAcct.credit(amount);
  47.                     System.out.println(Thread.currentThread().getName()+"完成转账");
  48.                 }
  49.             }
  50.         }
  51.         // 得到锁的hash值
  52.         int fromHash = System.identityHashCode(fromAcct);
  53.         int toHash = System.identityHashCode(toAcct);
  55.         // 根据hash值来上锁 不管是汇款账户还是入款账户，总是Hash值小的先锁，则对象锁的顺序是固定的
  56.         if (fromHash < toHash) { 
  57.             synchronized (fromAcct) { 
  58.                 System.out.println(Thread.currentThread().getName()+"获取账户"+fromAcct.getName()+"锁");
  59.                 synchronized (toAcct) { 
  60.                     System.out.println(Thread.currentThread().getName()+"获取账户"+toAcct.getName()+"锁");
  61.                     new Helper().transfer();
  62.                 }
  63.             }
  65.         } else if (fromHash > toHash) { // 根据hash值来上锁
  66.             synchronized (toAcct) { 
  67.                 System.out.println(Thread.currentThread().getName()+"获取账户"+toAcct.getName()+"锁");
  68.                 synchronized (fromAcct) { 
  69.                     System.out.println(Thread.currentThread().getName()+"获取账户"+fromAcct.getName()+"锁");
  70.                     new Helper().transfer();
  71.                 }
  72.             }
  73.         } else { //如果是同对象，由于 synchronized 已经支持可重入锁，所以并发的同账户互相转账不会产生死锁，锁顺序不产生影响
  74.             synchronized (fromAcct) { 
  75.                 synchronized (toAcct) { 
  76.                     new Helper().transfer();
  77.                 }
  78.             }
  79.         }
  80.     }
  81. }

程序执行结果

  1. Thread-0获取账户A锁
  2. Thread-0获取账户B锁
  3. Thread-0完成转账
  4. Thread-1获取账户A锁
  5. Thread-1获取账户B锁
  6. Thread-1完成转账

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

协作锁之间发生死锁

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

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

  1. public class CooperatingDeadlock {
  3.     public static void main(String[] args) {
  4.         ProductProducer productProducer = new ProductProducer();
  5.         ProductDepository productDepository = new ProductDepository();
  6.         productProducer.setProductDepository(productDepository);
  8.         productProducer.start();
  9.         productDepository.start();
  11.         while (true){
  12.             try {
  13.                 Thread.sleep(1000);
  14.             }catch (Exception e){
  15.                 e.printStackTrace();
  16.             }
  17.         }
  18.     }
  20. }
  22. class ProductProducer extends Thread{
  24.     public void setProductDepository(ProductDepository productDepository) {
  25.         this.productDepository = productDepository;
  26.     }
  28.     private ProductDepository productDepository;
  30.     @Override
  31.     public void run(){
  32.         produce();
  33.     }
  35.     // produce()需要ProductProducer对象锁
  36.     private synchronized void produce(){
  37.         do {
  38.             Product p = new Product(this);
  39.             System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，生产商品，并向仓库注册");
  40.             this.productDepository.addAvailable(p);
  42.             try{
  43.                 Thread.sleep(100);
  44.             }catch (Exception e){
  45.                 e.printStackTrace();
  46.             }
  47.         }while (true);
  48.     }
  50.     public synchronized void handle(Product product) {
  51.         System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，加工商品,生成编号");
  52.         product.setNo(System.currentTimeMillis());
  53.     }
  54. }
  56. class ProductDepository extends Thread{
  58.     public ProductDepository(){
  59.         availableProductList = new ArrayList<>();
  60.     }
  62.     private ArrayList<Product> availableProductList;
  64.     @Override
  65.     public void run(){
  66.         handleAvailable();
  67.     }
  69.     public synchronized void addAvailable(Product product) {
  70.         System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，注册到仓库");
  71.         availableProductList.add(product);
  72.     }
  74.     // handleAvailable()需要ProductDepository对象锁
  75.     public synchronized void handleAvailable() {
  76.         System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，将注册的商品进行加工");
  77.         do{
  78.             for (Product t : availableProductList)
  79.                 // 调用handle()需要ProductProducer对象锁
  80.                 t.handle();
  82.             availableProductList.clear();
  83.             try {
  84.                 Thread.sleep(100);
  85.             } catch (InterruptedException e) {
  86.                 e.printStackTrace();
  87.             }
  88.         }while (true);
  89.     }
  91. }
  93. class Product{
  94.     private  ProductProducer productProducer;
  96.     public Product(){}
  98.     public void setNo(Long no) {
  99.         this.no = no;
  100.     }
  102.     private Long no;
  104.     public Product(ProductProducer productProducer){
  105.         this.productProducer = productProducer;
  106.     }
  108.     public void handle(){
  109.         this.productProducer.handle(this);
  110.     }
  111. }

此时我们执行程序：

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

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

开放调用避免死锁

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

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

我们可以这样来改造：

  1. public class OpenMethodCooperationDeadLock { 
  2.     public static void main(String[] args) { 
  3.         OpenMethodProductProducer productProducer = new OpenMethodProductProducer();
  4.         OpenMethodProductDepository productDepository = new OpenMethodProductDepository();
  5.         productProducer.setProductDepository(productDepository);
  7.         productProducer.start();
  8.         productDepository.start();
  10.         while (true){ 
  11.             try { 
  12.                 Thread.sleep(1000);
  13.             }catch (Exception e){ 
  14.                 e.printStackTrace();
  15.             }
  16.         }
  17.     }
  19. }
  21. class OpenMethodProductProducer extends Thread{ 
  23.     public void setProductDepository(OpenMethodProductDepository productDepository) { 
  24.         this.productDepository = productDepository;
  25.     }
  27.     private OpenMethodProductDepository productDepository;
  29.     @Override
  30.     public void run(){ 
  31.         produce();
  32.     }
  34.     private void produce(){ 
  35.         do { 
  36.             OpenMethodProduct p = null;
  37.             //需要ProductProducer对象锁，但是缩小锁的范围，不会同时去获取两个锁
  38.             synchronized (this){ 
  39.                 System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，生产商品，并向仓库注册");
  40.                 p = new OpenMethodProduct(this);
  41.             }
  43.             if (null != p){ 
  44.                 System.out.println(Thread.currentThread().getName()+"向仓库注册");
  45.                 this.productDepository.addAvailable(p);
  46.             }
  48.             try{ 
  49.                 Thread.sleep(100);
  50.             }catch (Exception e){ 
  51.                 e.printStackTrace();
  52.             }
  53.         }while (true);
  54.     }
  56.     public synchronized void handle(OpenMethodProduct product) { 
  57.         System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，加工商品,生成编号");
  58.         product.setNo(System.currentTimeMillis());
  59.     }
  60. }
  62. class OpenMethodProductDepository extends Thread{ 
  64.     public OpenMethodProductDepository(){ 
  65.         availableProductList = new ArrayList<>();
  66.     }
  68.     private ArrayList<OpenMethodProduct> availableProductList;
  70.     @Override
  71.     public void run(){ 
  72.         handleAvailable();
  73.     }
  75.     public synchronized void addAvailable(OpenMethodProduct product) { 
  76.         System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，注册到仓库");
  77.         availableProductList.add(product);
  78.     }
  80.     public void handleAvailable() { 
  81.         do{ 
  82.             ArrayList<OpenMethodProduct> availableProductListCopy;
  83.             //需要ProductDepository对象锁，但是缩小锁的范围，不会同时去获取两个锁
  84.             synchronized (this){ 
  85.                 System.out.println(Thread.currentThread().getName()+"获取"+getClass().getName()+"对象锁，准备将注册的商品进行加工");
  86.                 availableProductListCopy = new ArrayList<>(availableProductList);
  87.                 availableProductList.clear();
  88.             }
  90.             for (OpenMethodProduct t : availableProductListCopy)
  91.                 // 调用handle()需要ProductProducer对象锁
  92.                 t.handle();
  93.             try { 
  94.                 Thread.sleep(100);
  95.             } catch (InterruptedException e) { 
  96.                 e.printStackTrace();
  97.             }
  98.         }while (true);
  99.     }
  101. }
  103. class OpenMethodProduct{ 
  104.     private  OpenMethodProductProducer productProducer;
  106.     public OpenMethodProduct(){ }
  108.     public void setNo(Long no) { 
  109.         this.no = no;
  110.     }
  112.     private Long no;
  114.     public OpenMethodProduct(OpenMethodProductProducer productProducer){ 
  115.         this.productProducer = productProducer;
  116.     }
  118.     public void handle(){ 
  119.         this.productProducer.handle(this);
  120.     }
  121. }

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

  1. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
  2. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
  3. Thread-0向仓库注册
  4. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
  5. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
  6. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，加工商品,生成编号
  7. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
  8. Thread-0向仓库注册
  9. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
  10. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
  11. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
  12. Thread-0向仓库注册
  13. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
  14. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，加工商品,生成编号
  15. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
  16. Thread-0向仓库注册
  17. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
  18. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
  19. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，加工商品,生成编号
  20. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，加工商品,生成编号
  21. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
  22. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
  23. Thread-0向仓库注册
  24. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
  25. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，准备将注册的商品进行加工
  26. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
  27. Thread-0向仓库注册
  28. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库
  29. Thread-1获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，加工商品,生成编号
  30. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductProducer对象锁，生产商品，并向仓库注册
  31. Thread-0向仓库注册
  32. Thread-0获取com.pubutech.multithread.example.deadlock.OpenMethodProductDepository对象锁，注册到仓库

RetreenLock锁超时解决死锁

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

发表评论

表情：
评论列表 （有 0 条评论，485人围观）

还没有评论，来说两句吧...

相关阅读

    相关 多线程 死锁

    死锁: 如果一个资源被一个线程占用，而且无法释放线程资源，导致其他线程无法访问这个字段，一直处于等待状态，这样就会形成 线程死锁。 例子: package com.

    缺乏、安全感缺乏、安全感/ 0 赞/ 135 阅读

    相关 多线程死锁

    / 死锁：二个线程同时锁住一个变量时。 锁住一个变量之后，尽快操作完成解锁，解锁之前不要再锁住其它变量，否则会互锁（死锁）。 /

    川长思鸟来川长思鸟来/ 0 赞/ 422 阅读

    相关 多线程死锁

    峨眉山月半轮秋,影入平羌江水流 Java线程的死锁一直都是经典的多线程问题;因为不同的线程都在等待根本不可能被释放的锁,从而导致所有的任务都不能继续执行; 示例代码:

    た 入场券た 入场券/ 0 赞/ 497 阅读

    相关 多线程死锁实例与定位

    既然可以上锁，那么假如有2个线程，一个线程想先锁对象1，再锁对象2，恰好另外有一个线程先锁对象2，再锁对象1。在这个过程中，当线程1把对象1锁好以后，就想去锁对象2，但是不巧，

    淡淡的烟草味﹌淡淡的烟草味﹌/ 0 赞/ 353 阅读

    相关 多线程死锁

    同步锁使用的弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：程序出现无限等待，这种现象我们称为死锁。这种情况能避免就避免掉。

    雨点打透心脏的1/2处雨点打透心脏的1/2处/ 0 赞/ 488 阅读