Java中死锁与活锁的具体实现

目录
  • 活锁与死锁
    • 活锁
    • 死锁
  • 死锁的四个必要条件
    • 互斥条件
    • 请求和保持条件
    • 不剥夺条件
    • 环路等待条件
  • 死锁示例
    • 死锁排查
    • 总结一下
  • 如何避免死锁
    • 预防死锁
    • 设置加锁顺序
  • 活锁示例
    • 解决活锁

活锁与死锁

活锁

活锁同样会发生在多个相互协作的线程间,当他们为了彼此间的响应而相互礼让,使得没有一个线程能够继续前进,那么就发生了活锁。同死锁一样,发生活锁的线程无法继续执行。

相当于两个在半路相遇的人:出于礼貌他们相互礼让,避开对方的路,但是在另一条路上又相遇了。就这样,不停地一直避让下去。。。。

死锁

两个或更多线程阻塞着等待其它处于死锁状态的线程所持有的锁。死锁通常发生在多个线程同时但以不同的顺序请求同一组锁的时候,死锁会让你的程序挂起无法完成任务。

死锁的四个必要条件

在 Java 中使用多线程,就会有可能导致死锁问题。死锁会让程序一直住,不再程序往下执行。我们只能通过中止并重启的方式来让程序重新执行。这是我们非常不愿意看到的一种现象,我们要尽可能避免死锁的情况发生!

互斥条件

指进程对所分配到的资源进行排它性使用,即在一段时间内某资源只由一个进程占用。如果此时还有其它进程请求资源,则请求者只能等待,直至占有资源的进程用完释放。

请求和保持条件

指进程已经保持至少一个资源,但又提出了新的资源请求,而该资源已被其它进程占有,此时请求进程阻塞,但又对自己已获得的其它资源保持不放。

不剥夺条件

指进程已获得的资源,在未使用完之前,不能被剥夺,只能在使用完时由自己释放。

环路等待条件

指在发生死锁时,必然存在一个进程——资源的环形链,即进程集合{A,B,C,···,Z} 中的A正在等待一个B占用的资源;B正在等待C占用的资源,……,Z正在等待已被A占用的资源。

死锁示例

/** @author Strive */
@SuppressWarnings("all")
public class DeadLock implements Runnable {
  public int flag = 1;

  /** 面包 */
  private static final Object bread = new Object();

  /** 水 */
  private static final Object water = new Object();

  @Override
  public void run() {
    if (flag == 1) {
      // 先吃面包再喝水,环路等待条件
      synchronized (bread) {
        try {
          Thread.sleep(500);
        } catch (Exception e) {
          e.printStackTrace();
        }
        System.out.println("面包吃了,等喝水。。。");
        synchronized (water) {
          System.out.println("面包吃了,水也喝到了");
        }
      }
    }
    if (flag == 0) {
      // 先喝水再吃面包,环路等待条件
      synchronized (water) {
        try {
          Thread.sleep(500);
        } catch (Exception e) {
          e.printStackTrace();
        }
        System.out.println("喝完水,等吃面包了。。。");
        synchronized (bread) {
          System.out.println("喝完水,面包也吃完了。。。");
        }
      }
    }
  }

  public static void main(String[] args) {
    DeadLock lockBread = new DeadLock();
    DeadLock lockWater = new DeadLock();
    lockBread.flag = 1;
    lockWater.flag = 0;
    // lockBread,lockWater 都处于可执行状态,但 JVM 线程调度先执行哪个线程是不确定的。
    // lockWater 的 run() 可能在 lockBread 的 run() 之前运行
    new Thread(lockBread).start();
    new Thread(lockWater).start();
  }
}

程序运行结果:

喝完水,等吃面包了。。。
面包吃了,等喝水。。。

死锁排查

先执行上面的代码,再进行排查!

1、使用 jps -l

D:\workspace-code\gitee\dolphin>jps -l
7072 org.jetbrains.jps.cmdline.Launcher
8824 sun.tools.jps.Jps
17212
4012 com.dolphin.thread.locks.DeadLock
6684 org.jetbrains.idea.maven.server.RemoteMavenServer36

4012 com.dolphin.thread.locks.DeadLock,粘贴进程号 4012

2、使用 jstack 4012

... ...
Java stack information for the threads listed above:
===================================================
"Thread-1":
        at com.dolphin.thread.locks.DeadLock.run(DeadLock.java:40)
        - waiting to lock <0x000000076bf9e3d8> (a java.lang.Object)
        - locked <0x000000076bf9e3e8> (a java.lang.Object)
        at java.lang.Thread.run(Thread.java:748)
"Thread-0":
        at com.dolphin.thread.locks.DeadLock.run(DeadLock.java:26)
        - waiting to lock <0x000000076bf9e3e8> (a java.lang.Object)
        - locked <0x000000076bf9e3d8> (a java.lang.Object)
        at java.lang.Thread.run(Thread.java:748)

Found 1 deadlock.

从打印信息我们可以看出:

  • Found 1 deadlock: 发现一个死锁;
  • Thread-1 locked <0x000000076bf9e3e8> waiting to lock <0x000000076bf9e3d8>:线程1,锁住了 0x000000076bf9e3e8 等待 0x000000076bf9e3d8 锁;
  • Thread-0 locked <0x000000076bf9e3d8> waiting to lock <0x000000076bf9e3e8>:线程0,锁住了 0x000000076bf9e3d8 等待 0x000000076bf9e3e8 锁;

总结一下

  • 当 DeadLock 类的对象 flag=1 时(lockBread),先锁定 bread,睡眠500毫秒;
  • 而 lockBread 在睡眠的时候另一个 flag==0 的对象(lockWater)线程启动,先锁定 water,睡眠500毫秒;
  • lockBread 睡眠结束后需要锁定 water 才能继续执行,而此时 water 已被 lockWater 锁定;
  • lockWater 睡眠结束后需要锁定 bread 才能继续执行,而此时 bread 已被 lockBread 锁定;
  • lockBread、lockWater 相互等待,都需要得到对方锁定的资源才能继续执行,从而死锁;

如何避免死锁

预防死锁

其实就是破坏死锁的四个必要条件!!!

  • 破坏互斥条件:使资源同时访问而非互斥使用,就没有进程会阻塞在资源上,从而不发生死锁。
  • 破坏请求和保持条件:采用静态分配的方式,静态分配的方式是指进程必须在执行之前就申请需要的全部资源,且直至所要的资源全部得到满足后才开始执行,只要有一个资源得不到分配,也不给这个进程分配其他的资源。
  • 破坏不剥夺条件:即当某进程获得了部分资源,但得不到其它资源,则释放已占有的资源,但是只适用于内存和处理器资源。
  • 破坏循环等待条件:给系统的所有资源编号,规定进程请求所需资源的顺序必须按照资源的编号依次进行。

设置加锁顺序

两个线程试图以不同的顺序来获得相同的锁,如果按照相同的顺序来请求锁,那么就不会出现循环的加锁依赖性,因此也就不会产生死锁,每个需要锁面包和锁水的线程都以相同的顺序来获取面包和水,那么就不会发生死锁了,如下图所示:

根据上图我们修改一下之前写的死锁代码,消除死锁!

@Override
public void run() {
    if (flag == 1) {
        // 先吃面包再喝水,环路等待条件
        synchronized (bread) {
            try {
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("面包吃了,等喝水。。。");
        }

        synchronized (water) {
            System.out.println("面包吃了,水也喝到了");
        }
    }
    if (flag == 0) {
        // 先喝水再吃面包,环路等待条件
        synchronized (water) {
            try {
                Thread.sleep(500);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("喝完水,等吃面包了。。。");
        }

        synchronized (bread) {
            System.out.println("喝完水,面包也吃完了。。。");
        }
    }
}

程序运行结果:

喝完水,等吃面包了。。。
面包吃了,等喝水。。。
面包吃了,水也喝到了
喝完水,面包也吃完了。。。

这样就可以消除死锁发生~~~

活锁示例

import java.lang.management.ManagementFactory;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

/** @author Strive */
public class LiveLock {
  static ReentrantLock bread = new ReentrantLock();
  static ReentrantLock water = new ReentrantLock();

  public static void main(String[] args) {
    String name = ManagementFactory.getRuntimeMXBean().getName();
    String pid = name.split("@")[0];
    System.out.println("Pid is:" + pid);
    System.out.println("jstack " + pid);

    ExecutorService executorService = Executors.newCachedThreadPool();

    executorService.submit(
        () -> {
          try {
            // 尝试获得 bread 锁
            while (bread.tryLock(10, TimeUnit.SECONDS)) {
              System.out.println("拿到面包了,等着拿水。。。");
              TimeUnit.SECONDS.sleep(1);

              // 判断 water 是否被锁住,如果锁住,退出!再次尝试获取 water 锁
              boolean locked = water.isLocked();
              if (locked) {
                bread.unlock();
                continue;
              }

              // 尝试获得 water 锁
              boolean w = water.tryLock(10, TimeUnit.SECONDS);
              // 如果没有获取到 water 锁,释放 bread 锁,再次尝试!
              if (!w) {
                bread.unlock();
                continue;
              }
              System.out.println("拿到水了");
              break;
            }
            System.out.println("吃面包,喝水!");
          } catch (InterruptedException e) {
            System.out.println("线程中断");
          } finally {
            water.unlock();
            bread.unlock();
          }
        });

    executorService.submit(
        () -> {
          try {
            while (water.tryLock(10, TimeUnit.SECONDS)) {
              System.out.println("拿到水了,等着拿面包。。。");
              TimeUnit.SECONDS.sleep(2);

              // 判断 bread 是否被锁住,如果锁住,退出!再次尝试获取 bread 锁
              boolean locked = bread.isLocked();
              if (locked) {
                water.unlock();
                continue;
              }

              // 尝试获得 bread 锁
              boolean b = bread.tryLock(10, TimeUnit.SECONDS);
              // 如果没有获取到 bread 锁,释放 water 锁,再次尝试!
              if (!b) {
                water.unlock();
                continue;
              }
              System.out.println("拿到面包了");
              break;
            }
            System.out.println("喝水,吃面包!");
          } catch (InterruptedException e) {
            System.out.println("线程中断");
          } finally {
            bread.unlock();
            water.unlock();
          }
        });
    executorService.shutdown();
  }
}

程序运行结果:

Pid is:8788
jstack 8788
拿到面包了,等着拿水。。。
拿到水了,等着拿面包。。。
拿到面包了,等着拿水。。。
拿到水了,等着拿面包。。。
拿到面包了,等着拿水。。。
拿到面包了,等着拿水。。。
拿到水了,等着拿面包。。。

已经输出打印了 Pid,尝试自己用 jstack 调试一下吧!可以参考如何排查死锁的章节~

解决活锁

锁让出的时候添加随机睡眠时间

修改上面的程序,参考下面的代码:

executorService.submit(
        () -> {
          try {
            // 尝试获得 bread 锁
            while (bread.tryLock(10, TimeUnit.SECONDS)) {
              System.out.println("拿到面包了,等着拿水。。。");
              TimeUnit.SECONDS.sleep(1);

              // 判断 water 是否被锁住,如果锁住,退出!再次尝试获取 water 锁
              boolean locked = water.isLocked();
              if (locked) {
                bread.unlock();
                // 避免活锁
                TimeUnit.MILLISECONDS.sleep(1000);
                continue;
              }

              // 尝试获得 water 锁
              boolean w = water.tryLock(10, TimeUnit.SECONDS);
              // 如果没有获取到 water 锁,释放 bread 锁,再次尝试!
              if (!w) {
                bread.unlock();
                continue;
              }
              System.out.println("拿到水了");
              break;
            }
            System.out.println("吃面包,喝水!");
          } catch (InterruptedException e) {
            System.out.println("线程中断");
          } finally {
            water.unlock();
            bread.unlock();
          }
        });

executorService.submit(
    () -> {
        try {
            while (water.tryLock(10, TimeUnit.SECONDS)) {
                System.out.println("拿到水了,等着拿面包。。。");
                TimeUnit.SECONDS.sleep(2);

                // 判断 bread 是否被锁住,如果锁住,退出!再次尝试获取 bread 锁
                boolean locked = bread.isLocked();
                if (locked) {
                    water.unlock();
                    // 避免活锁
                    TimeUnit.MILLISECONDS.sleep(1500);
                    continue;
                }

                // 尝试获得 bread 锁
                boolean b = bread.tryLock(10, TimeUnit.SECONDS);
                // 如果没有获取到 bread 锁,释放 water 锁,再次尝试!
                if (!b) {
                    water.unlock();
                    continue;
                }
                System.out.println("拿到面包了");
                break;
            }
            System.out.println("喝水,吃面包!");
        } catch (InterruptedException e) {
            System.out.println("线程中断");
        } finally {
            bread.unlock();
            water.unlock();
        }
    });
executorService.shutdown();

程序输出结果:

Pid is:18256
jstack 18256
拿到面包了,等着拿水。。。
拿到水了,等着拿面包。。。
拿到面包了
喝水,吃面包!
拿到面包了,等着拿水。。。
拿到水了
吃面包,喝水!

Process finished with exit code 0

到此这篇关于Java中死锁与活锁的具体实现的文章就介绍到这了,更多相关Java 死锁与活锁内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java并发中死锁、活锁和饥饿是什么意思

    解答 死锁是指两个或者两个以上的进程(或线程)在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,他们将无法推进下去. 如果线程的智力不够, 且都秉承着"谦让"的原则,主动将资源释放给他人使用,那么就会导致资源不断地在两个线程间跳动,而没有一个线程可以同时拿到所有资源正常执行.这种情况就是活锁. 饥饿是指某一个或者多个线程因为种种原因无法获得所需要的资源,导致一直无法执行.比如它的线程优先级可能太低,而高优先级的线程不断抢占它需要的资源,导致低优先级线程无法工作.  补充

  • Java中常见死锁与活锁的实例详解

    本文介绍了Java中常见死锁与活锁的实例详解,分享给大家,具体如下: 顺序死锁:过度加锁,导致由于执行顺序的原因,互相持有对方正在等待的锁 资源死锁:多个线程在相同的资源上发生等待 由于调用顺序而产生的死锁 public class Test { Object leftLock = new Object(); Object rightLock = new Object(); public static void main(String[] args) { final Test test = ne

  • Java中死锁与活锁的具体实现

    目录 活锁与死锁 活锁 死锁 死锁的四个必要条件 互斥条件 请求和保持条件 不剥夺条件 环路等待条件 死锁示例 死锁排查 总结一下 如何避免死锁 预防死锁 设置加锁顺序 活锁示例 解决活锁 活锁与死锁 活锁 活锁同样会发生在多个相互协作的线程间,当他们为了彼此间的响应而相互礼让,使得没有一个线程能够继续前进,那么就发生了活锁.同死锁一样,发生活锁的线程无法继续执行. 相当于两个在半路相遇的人:出于礼貌他们相互礼让,避开对方的路,但是在另一条路上又相遇了.就这样,不停地一直避让下去.... 死锁

  • java 中死锁问题的实例详解

    java 中死锁问题的实例详解 先看代码在做解释 public class DeadLock implements Runnable{ String a; String b; boolean flag; public DeadLock(String a,String b,boolean flag){ this.a=a; this.b=b; this.flag=flag; } public void run(){ if(flag){ // while(true){ synchronized(a){

  • Java中死锁的原理实战分析

    本文实例讲述了Java中死锁的原理.分享给大家供大家参考,具体如下: 一 点睛 当两个线程相互等待对方释放同步监视器时就会发生死锁,Java虚拟机没有监测.也没有采用措施来处理死锁情况,所以多线程编程时应该采取措施避免死锁的出现. 一旦出现死锁,整个程序既不会发生任何异常,也不会给出任何提示,只是所有线程处于阻塞状态,无法继续. 二 代码 class A { public synchronized void foo( B b ) { System.out.println("当前线程名: &quo

  • Java中死锁产生的原因有哪些?

    目录 死锁产生原因 解决死锁 总结 前言: 死锁(Dead Lock)指的是两个或两个以上的运算单元(进程.线程或协程),都在等待对方释放资源,但没有一方提起释放资源,从而造成了一种阻塞的现象就称为死锁. 比如线程 1 拥有了锁 A 的情况下试图获取锁 B,而线程 2 又在拥有了锁 B 的情况下试图获取锁 A,这样双方就进入相互阻塞等待的情况, 如下图所示:   死锁的代码实现如下: import java.util.concurrent.TimeUnit; public class DeadL

  • 详解java中产生死锁的原因及如何避免

    1. Java中导致死锁的原因 Java中死锁最简单的情况是,一个线程T1持有锁L1并且申请获得锁L2,而另一个线程T2持有锁L2并且申请获得锁L1,因为默认的锁申请操作都是阻塞的,所以线程T1和T2永远被阻塞了.导致了死锁.这是最容易理解也是最简单的死锁的形式.但是实际环境中的死锁往往比这个复杂的多.可能会有多个线程形成了一个死锁的环路,比如:线程T1持有锁L1并且申请获得锁L2,而线程T2持有锁L2并且申请获得锁L3,而线程T3持有锁L3并且申请获得锁L1,这样导致了一个锁依赖的环路:T1依

  • java实现死锁的示例代码

    什么是死锁 我们先看看这样一个生活中的例子:在一条河上有一座桥,桥面较窄,只能容纳一辆汽车通过,无法让两辆汽车并行.如果有两辆汽车A和B分别由桥的两端驶上该桥,则对于A车来说,它走过桥面左面的一段路(即占有了桥的一部分资源),要想过桥还须等待B车让出右边的桥面,此时A车不能前进:对于B车来说,它走过桥面右边的一段路(即占有了桥的一部分资源),要想过桥还须等待A车让出左边的桥面,此时B车也不能前进.两边的车都不倒车,结果造成互相等待对方让出桥面,但是谁也不让路,就会无休止地等下去.这种现象就是死锁

  • java避免死锁的常见方法代码解析

    死锁 索是一个非常有用的工具,运用场景非常多,因为它使用起来非常简单,而且易于理解.但同时它也会带来一些困扰,那就是可能会引起死锁,一旦产生死锁,就会造成系统功能不可用.让我们先来看一段代码,这段代码会引起死锁,使线程 thread_1 和线程 thread_2 互相等待对方释放锁. package thread; public class DeadLockDemo { private static String A = "A"; private static String B = &

  • 详解Java中synchronized关键字的死锁和内存占用问题

    先看一段synchronized 的详解: synchronized 是 java语言的关键字,当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码. 一.当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时,一个时间内只能有一个线程得到执行.另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块. 二.然而,当一个线程访问object的一个synchronized(this)同步代码块时,另一个线程仍然可以

随机推荐