Java最简单的死锁例子

骑猪看日落 2021-11-08 23:16 474阅读 0赞

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。

简单来说：

  1. 线程1和线程2的执行逻辑中都需要锁定对象A和对象B。

  2. 线程1在执行中先锁定了A对象。

  3. 线程2在执行中锁定了B对象。

  4. 线程1需要锁定B对象时发现B对象已经被其他线程锁住，所以线程1需要等待B对象锁释放后继续执行。

  5. 线程2需要锁定A对象时发现A对象已经被其他线程锁住，所以线程2需要等待A对象锁释放后继续执行。

这样就产生了死锁现象，以下图展示了死锁：

20180406071514470

简单代码实现：

  1. package com.btt.test;
  3. public class DeadLock {
  4.     private Object A = new Object();
  5.     private Object B = new Object();
  7.     public void run() {
  8.         System.out.println("开始执行线程");
  9.     }
  10.     public Object getA() {
  11.         return A;
  12.     }
  13.     public void setA(Object a) {
  14.         A = a;
  15.     }
  16.     public Object getB() {
  17.         return B;
  18.     }
  19.     public void setB(Object b) {
  20.         B = b;
  21.     }
  23.     public static void main(String[] args) {
  24.         final DeadLock dl1 = new DeadLock();
  26.         Runnable r1 = new Runnable() {
  27.             public void run() {
  28.                 synchronized (dl1.getA()) {
  30.                     String tName = Thread.currentThread().getName();
  32.                     System.out.println("我是线程" + tName + ",我拿到了A对象的锁");
  34.                     try {
  35.                         Thread.sleep(3000);
  36.                     } catch (InterruptedException e) {
  37.                         e.printStackTrace();
  38.                     }
  39.                     System.out.println("我需要拿B对象的锁啦");
  40.                     synchronized (dl1.getB()) {
  41.                         System.out.println("线程1开始跑了");
  42.                     }
  43.                 };
  44.             }
  45.         };
  48.         Runnable r2 = new Runnable() {
  49.             public void run() {
  50.                 synchronized (dl1.getB()) {
  51.                     String tName = Thread.currentThread().getName();
  52.                     System.out.println("我是线程" + tName + ",我拿到了B对象的锁");
  54.                     try {
  55.                         Thread.sleep(3000);
  56.                     } catch (InterruptedException e) {
  57.                         e.printStackTrace();
  58.                     }
  59.                     System.out.println("我需要拿A对象的锁啦");
  60.                     synchronized (dl1.getA()) {
  61.                         System.out.println("线程2开始跑了");
  62.                     };
  63.                 };
  64.             }
  65.         };
  67.         Thread t1 = new Thread(r1); 
  68.         t1.setName("t1");
  69.         t1.start();
  72.         Thread t2 = new Thread(r2);
  73.         t2.setName("t2");
  74.         t2.start();
  75.     }
  79. }

打印台输出结果：

  1. 我是线程t1,我拿到了A对象的锁
  2. 我是线程t2,我拿到了B对象的锁
  3. 我需要拿A对象的锁啦
  4. 我需要拿B对象的锁啦

发表评论

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

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

相关阅读

    相关 死锁_Java产生死锁的简单案例

    一、简介 多个线程各自占有一些共享资源，并且互相等待其它线程占有的资源才能进行，而导致的两个或多个线程都在等待对方释放资源，都停止执行的情景。某一个同步块同时拥有“两个以

    我就是我我就是我/ 0 赞/ 91 阅读

    相关 一个死锁的例子

    死锁: 死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。 死锁的四个必要条件：

    深藏阁楼爱情的钟深藏阁楼爱情的钟/ 0 赞/ 340 阅读

    相关 Java最简单的死锁例子

    死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无法推进下去。 简单来说： 1. 线程1和线程2的执行逻

    骑猪看日落骑猪看日落/ 0 赞/ 475 阅读