死锁

最新推荐文章于 2020-06-30 18:12:03 发布

原创最新推荐文章于 2020-06-30 18:12:03 发布 · 225 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#多线程 #java

多线程专栏收录该内容

8 篇文章

订阅专栏

本文深入探讨了死锁这一多线程编程中常见的问题，详细解释了死锁产生的原因及条件，通过具体示例代码展示了线程如何因争夺锁资源而陷入无限等待的状态，强调了预防死锁的重要性。

1. 什么是死锁

两个线程,两个锁对象
线程A获取锁对象1,线程B获取锁对象2,
线程A还需要锁对象2,才能执行
线程B还需要锁对象1,才能执行
线程A和B就相互等待对象释放锁对象,这种情况称为死锁!

public class DeadLockDemo {
public static void main(String[] args) {
//1.两个锁对象
Object obj1 = new Object();
Object obj2 = new Object();
//2.两个线程
//线程A
new Thread(new Runnable() {
@Override
public void run() {
//3.需要反向嵌套获取锁对象
synchronized (obj1) {
System.out.println(“线程A获取锁对象1,还需要获取锁对象2…”);
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj2) {
System.out.println(“线程A的任务执行了…”);
}
}
}
}).start();

    //线程B
    new Thread(new Runnable() {
        @Override
        public void run() {
            //3.需要反向嵌套获取锁对象
            synchronized (obj2) {
                System.out.println("线程B获取锁对象2,还需要获取锁对象1....");
                try {
                    Thread.sleep(20);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj1) {
                    System.out.println("线程B的任务执行了...");
                }
            }
        }
    }).start();

}

}
注意:死锁只能进行避免,一旦出现死锁无法解决!!

2. 产生死锁的条件

a.至少有两个线程
b.至少有两个锁对象
c.需要反向嵌套获取锁对象

3. 死锁演示

public class DeadLockDemo {
    public static void main(String[] args) {
        //1.两个锁对象
        Object obj1 = new Object();
        Object obj2 = new Object();
        //2.两个线程
        //线程A
        new Thread(new Runnable() {
            @Override
            public void run() {
                //3.需要反向嵌套获取锁对象
                synchronized (obj1) {
                    System.out.println("线程A获取锁对象1,还需要获取锁对象2....");
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj2) {
                        System.out.println("线程A的任务执行了...");
                    }
                }
            }
        }).start();

        //线程B
        new Thread(new Runnable() {
            @Override
            public void run() {
                //3.需要反向嵌套获取锁对象
                synchronized (obj2) {
                    System.out.println("线程B获取锁对象2,还需要获取锁对象1....");
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized (obj1) {
                        System.out.println("线程B的任务执行了...");
                    }
                }
            }
        }).start();

    }
}