一个简单死锁的例子

「爱情、让人受尽委屈。」 2022-07-19 02:50 247阅读 0赞

转自：http://www.open-open.com/code/view/1426489433101

package com.spri.test;
    
    
    /** 
    * 在实际编程中，要尽量避免出现死锁的情况，但是让你故意写一个死锁的程序时似乎也不太简单（有公司会出这样的面试题），
    * 以下是一个简单的死锁例子。
    * 线程的同步化可能会造成死锁，死锁发生在两个线程相互持有对方正在等待的东西（实际是两个线程共享的东西）。
    * 只要有两个线程和两个对象就可能产生死锁。
    * 一个简单的死锁类 
    * 当DeadLock类的对象flag==1时（td1），先锁定o1,睡眠500毫秒 
    * 而td1在睡眠的时候另一个flag==0的对象（td2）线程启动，先锁定o2,睡眠500毫秒 
    * td1睡眠结束后需要锁定o2才能继续执行，而此时o2已被td2锁定； 
    * td2睡眠结束后需要锁定o1才能继续执行，而此时o1已被td1锁定； 
    * td1、td2相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。 
    */  
    public class DeadLock implements Runnable {  
        public int flag = 1;  
        //静态对象是类的所有对象共享的  
        private static Object o1 = new Object(), o2 = new Object();  
        @Override  
        public void run() {  
            System.out.println("flag=" + flag);  
            if (flag == 1) {  
                synchronized (o1) {  
                    try {  
                        Thread.sleep(500);  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                    synchronized (o2) {  
                        System.out.println("1");  
                    }  
                }  
            }  
            if (flag == 0) {  
                synchronized (o2) {  
                    try {  
                        Thread.sleep(500);  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                    synchronized (o1) {  
                        System.out.println("0");  
                    }  
                }  
            }  
        }  
      
        public static void main(String[] args) {  
              
            DeadLock td1 = new DeadLock();  
            DeadLock td2 = new DeadLock();  
            td1.flag = 1;  
            td2.flag = 0;  
            //td1,td2都处于可执行状态，但JVM线程调度先执行哪个线程是不确定的。  
            //td2的run()可能在td1的run()之前运行  
            new Thread(td1).start();  
            new Thread(td2).start();  
      
        }  
    }  转子

package com.spri.test;
    
    /** 
    * 在实际编程中，要尽量避免出现死锁的情况，但是让你故意写一个死锁的程序时似乎也不太简单（有公司会出这样的面试题），
    * 以下是一个简单的死锁例子。
    * 线程的同步化可能会造成死锁，死锁发生在两个线程相互持有对方正在等待的东西（实际是两个线程共享的东西）。
    * 只要有两个线程和两个对象就可能产生死锁。
    * 一个简单的死锁类 
    * 当DeadLock类的对象flag==1时（td1），先锁定o1,睡眠500毫秒 
    * 而td1在睡眠的时候另一个flag==0的对象（td2）线程启动，先锁定o2,睡眠500毫秒 
    * td1睡眠结束后需要锁定o2才能继续执行，而此时o2已被td2锁定； 
    * td2睡眠结束后需要锁定o1才能继续执行，而此时o1已被td1锁定； 
    * td1、td2相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。 
    */  
    public class DeadLock implements Runnable {  
        public int flag = 1;  
        //静态对象是类的所有对象共享的  
        private static Object o1 = new Object(), o2 = new Object();  
        @Override  
        public void run() {  
            System.out.println("flag=" + flag);  
            if (flag == 1) {  
                synchronized (o1) {  
                    try {  
                        Thread.sleep(500);  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                    synchronized (o2) {  
                        System.out.println("1");  
                    }  
                }  
            }  
            if (flag == 0) {  
                synchronized (o2) {  
                    try {  
                        Thread.sleep(500);  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
                    synchronized (o1) {  
                        System.out.println("0");  
                    }  
                }  
            }  
        }  
      
        public static void main(String[] args) {  
              
            DeadLock td1 = new DeadLock();  
            DeadLock td2 = new DeadLock();  
            td1.flag = 1;  
            td2.flag = 0;  
            //td1,td2都处于可执行状态，但JVM线程调度先执行哪个线程是不确定的。  
            //td2的run()可能在td1的run()之前运行  
            new Thread(td1).start();  
            new Thread(td2).start();  
      
        }  
    }

发表评论取消回复

表情：

评论列表（有 0 条评论，247人围观）

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

相关阅读

相关 java实现死锁简单例子,Java死锁的简单例子

Java死锁的简单例子两个线程互相占有对方需要的资源而不释放，便形成了死锁。代码如下： Program.java /\\ \ 程序类 \ @author mic

青旅半醒/ 2023年01月13日 09:26/ 0 赞/ 152 阅读

相关死锁例子

/ 必定发生死锁的情况 / public class MustDeadLock implements Runnable {

r囧r小猫/ 2022年12月12日 02:16/ 0 赞/ 192 阅读

相关一个简单死锁的例子

转自：http://www.open-open.com/code/view/1426489433101 package com.spri.test;

「爱情、让人受尽委屈。」/ 2022年07月19日 02:50/ 0 赞/ 248 阅读

相关 Java线程死锁的简单例子

/ DeadLockDemo @author panjn @date 2017/4/1 / public class DeadLockDemo {

阳光穿透心脏的1/2处/ 2022年06月18日 08:45/ 0 赞/ 211 阅读

相关一个死锁的例子

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

深藏阁楼爱情的钟/ 2022年05月18日 07:58/ 0 赞/ 273 阅读

相关什么是死锁？自己动手写死锁。一个死锁的例子。死锁的四个条件，如何避免死锁。

文章目录一、什么是死锁二、动手写死锁三、发现排查死锁情况四、解决办法面试题就好像计算机二级一样扯淡的出一

我会带着你远行/ 2022年02月27日 17:20/ 0 赞/ 307 阅读

相关 Java最简单的死锁例子

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

骑猪看日落/ 2021年11月08日 23:16/ 0 赞/ 385 阅读

相关一个死锁的简单实现

死锁两个或两个以上进程在执行任务的时候由于争夺资源等待资源而发生互相等待的状态。四个必要条件互斥条件（进程对锁分配的资源排他性

墨蓝/ 2021年09月27日 11:52/ 0 赞/ 342 阅读

相关一个死锁发生的例子--Lock

接上一篇博客，使用Lock实现死锁 import java.util.concurrent.locks.Lock; import java.util.conc

待我称王封你为后i/ 2021年09月27日 08:28/ 0 赞/ 376 阅读

相关一个死锁发生的例子--synchronized

死锁发生的必要条件：（1）互斥条件：一个资源每次只能被一个进程使用。（2）请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。（3）不剥

绝地灬酷狼/ 2021年09月27日 08:26/ 0 赞/ 344 阅读