精华内容
下载资源
问答
  • java 死锁代码示例
    千次阅读
    2019-06-01 10:50:39

    一、死锁的产生条件

    • 互斥使用:一个资源只能分配给一个线程
    • 不可剥夺:资源只能由占有者释放,申请者不能强制剥夺
    • 请求保持:线程申请资源时,保持对原有资源的占有
    • 循环等待:存在一个进程等待队列:{P1 , P2 , … , Pn}, 其中P1等待P2占有的资源,P2等待P3占有的资源,…,Pn等待P1占有的资源,形成一个进程等待环路
      代码
    • 引用链接:https://www.jianshu.com/p/8cf78bf94f9d

    二、死锁代码示例

    自定义一个线程实现类,

    package com.yunshi.synchronizedtest;
    
    import org.hibernate.validator.internal.util.privilegedactions.NewInstance;
    
    /**
     * 
     死锁条件
    互斥使用:一个资源只能分配给一个线程
    不可剥夺:资源只能由占有者释放,申请者不能强制剥夺
    请求保持:线程申请资源时,保持对原有资源的占有
    循环等待:存在一个进程等待队列:{P1 , P2 , … , Pn}, 其中P1等待P2占有的资源,P2等待P3占有的资源,…,Pn等待P1占有的资源,形成一个进程等待环路
    代码
    
    思路
    
    定义两个资源o1,o2
    对象deadLock1占有资源o1,需要资源o2
    对象deadLock2占有资源o2,需要资源o1
    死锁产生
     * @author Administrator
     *
     */
    public class DeadLock implements Runnable{
    	/**
    	 * 定义两个Object对象,模拟两个线程占有的共享资源
    	 * 此处需要注意的是,o1和o2 需要有static修饰,定义为静态对象,这样o1和o2才能在多个线程之间调用,才属于共享资源,
    	 * 没有static修饰的话,DeadLock的每个实例对象中的 o1和o2 都将是独立存在,相互隔离的,
    	 */
    	public static Object o1= new Object();
    	public static Object o2= new Object();
    
    	public int flag; // 属性,又叫成员变量
    
    	public DeadLock(int flag) {
    		super();
    		this.flag = flag;
    	}
    
    	@Override
    	public void run() {
    		if (flag==1) {
    			// 代码块1
    			synchronized (o1) {
    				System.out.println("one-1");
    				try {
    					Thread.sleep(1000);
    				} catch (Exception e) {
    					e.printStackTrace();
    				}
    				synchronized (o2) {
    					System.out.println("one-2");
    				}
    			}
    		}else {
    			// 代码块2
    			synchronized (o2) {
    				System.out.println("two-1");
    				try {
    					Thread.sleep(1000);
    				} catch (InterruptedException e) {
    					e.printStackTrace();
    				}
    				synchronized (o1) {
    					System.out.println("two-2");
    				}
    			}
    		}
    	}
    
    	public static void main(String[] args) {
    		//创建线程1,flag 属性值为1
    		DeadLock deadLock1 = new DeadLock(1);
    		//创建线程1,flag 属性值为2
    		DeadLock deadLock2 = new DeadLock(2);
    		//启动线程1和线程2
    		/**
    		 * 线程1启动之后,调用顺序是
    		 * (1)执行代码块1,同时获取到o1对象锁,开始执行,线程沉睡1秒
    		 * (2)接着去获取o2的对象锁,由于第二个线程先获取的是o2的对象锁,所以需要等待代码块2执行完毕,才能获取到o2的对象锁
    		 */
    		new Thread(deadLock1).start();
    		/**
    		 * 线程2启动之后,调用顺序是
    		 * (1)执行代码块2,同时获取到o2对象锁,开始执行,线程沉睡1秒
    		 * (2)接着去获取o1的对象锁,由于第一个线程先获取的是o1的对象锁,所以需要等待代码块1执行完毕,才能获取到o1的对象锁
    		 */
    		new Thread(deadLock2).start();
    		/** 以上分析可得,线程一和线程二共用了对象o1和o2,各自都想要获取对方的锁,从而形成阻塞,一直等待下去,这种现象就是死锁。*/
    		
    	}
    	
    }
    

     

    更多相关内容
  • 本篇文章主要介绍了java实现死锁示例代码,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • java线程死锁代码示例

    2020-08-28 18:02:59
    主要介绍了java线程死锁代码示例,分享了一个简单线程死锁的例子,需要的朋友可以参考下。
  • java死锁代码示例

    2016-06-22 22:04:42
    * 线程死锁 * @author 签约test * */ public class TestDeadLock { /** * I want to say ,in there the lock1 and the lock2 isn’t * common lock ,But in there we must notice that the S

    /**
    * 线程死锁
    * @author 签约test
    *
    */
    public class TestDeadLock {
    /**
    * I want to say ,in there the lock1 and the lock2 isn’t
    * common lock ,But in there we must notice that the String lock1=””
    * and String lock2 = “” is a common lock ,because in the Constant pool
    * they are a common string ,so we must realize that if the String value
    * is same when we don’t use the keywords “new”,they will be a same final
    * field.
    */
    private static String lock1 = “”;
    private static String lock2 = “1”;

    private static class Thread1 extends Thread{
        @Override
        public void run() {
            synchronized(lock1){
                System.out.println("OK,the Thread1 have got the lock \"lock1\" " +
                        "and wait for sleep ,in a moment ,get the lock2 and " +
                        "finish all the work!!!");
                try {
                    //Onhn, he is sleeping ,Yeah I know
                    sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                //now ,I need the lock "lock2"
                synchronized(lock2){
                    System.out.println("OK , I am the Thread1 and I have got " +
                            "the \"lock2\" and I will finish all at once");
                }
            }
        }
    
    }
    private static class Thread2 extends Thread{
        @Override
        public void run() {
            synchronized(lock2){
                System.out.println("OK,I am the Thread 2 and 1 have got the lock \"lock2\"" +
                        "because I would like to make a deadLock ,Maybe you think I am so" +
                        "foolish ,but I want tell I am having a test ,yeah only  A test" +
                        "in the test I have got the lock \"lock2\"and I know that the Thrad1" +
                        "have got the lock \"lock1\" and I will go in a deadLock" +
                        "Yeah interesting!!!" +
                        "OK let's go");
    
                synchronized(lock1){
                    System.out.println("OK , I am the Thread2 and I know that" +
                            "the demo willn't run because I ....yeah I know " +
                            "A deadLock ,interesting!!!");
                }
            }
        }
    
    }
    
    /**
     * OK ,have a try
     * @param args
     */
    public static void main(String[] args) {
        Thread1 th1 = new Thread1();
        Thread2 th2 = new Thread2();
        /**
         * Yeah ,I deem that i should write a note to tell you what happened
         * but I think i have give the note the console ,yeah I have give it 
         * to console ,so I think new i needn't write note .enhn, I tell you
         * all of this 
         */
        //now we must start them ,and the JVM will get them run ,I konw
        //I won't interrupt
        th1.start();
        th2.start();
    
    }
    

    }

    展开全文
  • Java死锁代码示例

    2018-11-16 09:41:25
    public class DeadLocak { private final Object left = new Object(); private final Object right = new Object(); public void leftRight() throws Exception { synchronized (left) { ...
    public class DeadLocak {
    
        private final Object left = new Object();
        private final Object right = new Object();
    
        public void leftRight() throws Exception {
            synchronized (left) {
                Thread.sleep(2000);
                synchronized (right) {
                    System.out.println("leftRight end!");
                }
            }
        }
    
        public void rightLeft() throws Exception {
            synchronized (right) {
                Thread.sleep(2000);
                synchronized (left) {
                    System.out.println("rightLeft end!");
                }
            }
        }
    
        public static void main(String[] args) {
            final DeadLocak deadLocak = new DeadLocak();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        deadLocak.leftRight();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
    
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        deadLocak.rightLeft();
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }

    利用jstack -pid 号查看发现

     

     

    展开全文
  • Java死锁示例

    2020-07-23 09:33:08
    import java.util.concurrent.locks.ReentrantReadWriteLock; /** * 死锁 * * @Ahthor luohq * @Date 2020-07-23 */ public class Deadlock { public static void main(String[] args) { deadLock1(); //...

    模拟2种出现死锁的方式
    (1)锁资源互斥(锁资源被占用)
    (2)读写锁互斥性

    import java.util.concurrent.locks.ReentrantReadWriteLock;
    
    /**
     * 死锁
     *
     * @Ahthor luohq
     * @Date 2020-07-23
     */
    public class Deadlock {
    
    
        public static void main(String[] args) {
            deadLock1();
            //deadLock2();
            //wrLockDowngrade();
        }
    
    
        /**
         * 死锁 - 资源互斥
         */
        public static void deadLock1() {
            Object lock1 = new Object();
            Object lock2 = new Object();
    
            new Thread(() -> {
                synchronized (lock1) {
                    System.out.println("thread1 get lock1");
                    //睡眠5秒(模拟进行耗时的操作,同时以使thread2优先获取lock2)
                    sleep(5000L);
                    synchronized (lock2) {
                        System.out.println("thread1 get lock2");
                    }
                }
            }).start();
    
            new Thread(() -> {
                synchronized (lock2) {
                    System.out.println("thread2 get lock2");
                    sleep(5000L);
                    synchronized (lock1) {
                        System.out.println("thread2 get lock1");
                    }
                }
            }).start();
        }
    
        /**
         * 读写锁死锁 - 获取写锁后无法再获取读锁
         *
         * 1.读锁支持共享(可同时获取读锁、获取读锁后无法再获取写锁)
         * 2.写锁排他锁(获取写锁后无法再获取写锁、读锁)
         * 3.支持锁降级(写锁 -> 读锁)
         * 4.不支持锁升级(读锁 -> 写锁)
         */
        public static void deadLock2() {
            ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
            ReentrantReadWriteLock.ReadLock rLock = rwLock.readLock();
            ReentrantReadWriteLock.WriteLock wLock = rwLock.writeLock();
    
            new Thread(() -> {
                rLock.lock();
                System.out.println("thread1 get rLock");
                wLock.lock();
                System.out.println("thread1 get wLock");
                rLock.unlock();
                wLock.unlock();
            }).start();
    
        }
    
        /**
         * 锁降级 - 写锁降级为读锁
         * 同时ReentrantReadWriteLock支持线程内重入(若不支持重入则获取锁后,在同线程内再次获取锁则出现死锁)
         */
        public static void wrLockDowngrade() {
            ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
            ReentrantReadWriteLock.ReadLock rLock = rwLock.readLock();
            ReentrantReadWriteLock.WriteLock wLock = rwLock.writeLock();
    
            /** 【锁降级】可以正常执行:同一个线程中获取写锁 -> 获取读锁 -> 释放写锁 -> 释放读锁 */
            new Thread(() -> {
                wLock.lock();
                System.out.println("thread2 get wLock");
                rLock.lock();
                System.out.println("thread2 get rLock");
                wLock.unlock();
                rLock.unlock();
            }).start();
    
        }
    
        public static void sleep(Long mills) {
            try {
                Thread.sleep(mills);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    展开全文
  • 死锁的原因,解决死锁的一般逻辑,死锁代码示例
  • Java死锁的例子

    2014-03-29 12:05:20
    Java死锁的例子,非常的例子。经过本人验证
  • java死锁示例代码

    2021-03-15 11:31:12
    public class DeadLock {public static String obj1 = "obj1";public static String obj2 = "obj2";public static void main(String[] args) {Thread thread1 = new Thread(new Lock1());Thread thread2 = new Threa...
  • 解决Java线程死锁问题及代码实例。“死锁”是多线程中出现问题的一种情况,即:多个线程因竞争资源、进程推进顺序等原因而导致各进程同时被阻塞的情形,被阻塞的进程中一个或全部处于等待某个资源被释放达到自己执行...
  • Java死锁示例代码

    2020-02-15 22:49:13
    代码示例 public class DeadLock { private static Object key = new Object(); private static Object lock = new Object(); /** * flag = 1时 双线程都未能获取到对方的锁 死锁 * flag = 2时 线程1获取到线程...
  • java死锁简单案例

    2022-03-15 22:31:30
    1、线程死锁的概念: 我们都知道,线程在执行的过程中是占着CPU的资源的,当多个线程都需要一个被锁住的条件才能结束的时候,死锁就产生了! 还有一个经典的死锁现象: 经典的“哲学家就餐问题”,5个哲学家吃中餐,...
  • Java死锁代码演示 死锁的概念 知识储备 对象锁:Java一切皆对象,每个类都有一个class文件。由class文件可以new出对象,我们简单认识 下java对象,对象有个对象头信息,也就是这个对象概述,其中一条信息就是对象锁...
  • java并发编程:死锁代码示例 死锁概念: 死锁是指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。此时称系统处于死锁状态或系统...
  • Java死锁的简单例子

    2021-04-17 10:08:04
    Java死锁的简单例子两个线程互相占有对方需要的资源而不释放,便形成了死锁。代码如下:Program.java/*** 程序类* @author michael**/public class Program implements Runnable {//两个静态的资源public static ...
  • 三、产生死锁的实例代码java)四、如何避免死锁? 一、什么是死锁? 下面图片参考 JavaGuide中的内容: 死锁的概念: 死锁:指的是相互两个线程之间都需要获取对方的资源才能进行下一步,如果每个线程都不肯将...
  • 本源代码是博客《Java 多线程编程之七:死锁(附源代码)》附带的实例性源代码。原博客链接地址:http://blog.csdn.net/defonds/archive/2010/01/26/5258120.aspx。
  • 本文将通过Java代码演示一个死锁程序,并用JDK自带的工具`jstack`工具,来验证下是否真正的有死锁发生。明白了死锁发生的机制,我们可以想办法避免死锁发生,第一种方法是注意加锁顺序。第二种避免死锁的方式是,...
  • Java线程死锁代码示例

    2021-02-25 19:14:51
    死锁$2.run(死锁.java:35) * - waiting to lock  (a java.lang.Object) * - locked  (a java.lang.Object) * at java.lang.Thread.run(Thread.java:748) * "Thread-0": * at org.example.thread....
  • Java死锁示例及检测

    2021-02-28 14:11:14
    死锁是指多个线程在等待不可能被...首先看一个类DealThread,这个类含有互斥锁,以synchronized代码块的形式表示,线程A使用锁的顺序是lock1->lock2。线程B使用锁的顺序是lock2->lock1。在一个线程获得一个...
  • 死锁代码示例

    2021-12-01 18:01:26
    public class DeadLock { public static void main(String[] args) { Object object1 = new Object(); Object object2 = new Object(); MyThread myThread1 = new MyThread(object1,object2,true);...
  • Java死锁的例子及其解决办法 什么是死锁? 过多的同步可能会造成死锁。(相互等资源) 某一个同步块同时拥有两个或者两个以上的对象的锁时,可能发生死锁。 比如下面这个例子: 线程1已经持有了lipstick锁并想要...
  • 主要介绍了java中常见的死锁以及解决方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • JAVA死锁代码实例

    2017-08-18 08:56:55
    所谓死锁,很多人知道就是两个现成互相等待对方占有的资源,而出现无限等待下去的情况,但是涉及到写代码的话不一定都能写出来,以下思路作为参考: (1)创建两个线程,分别持有两个lock,比如是lock1和lock2 (2)...
  • 主要介绍了java中产生死锁的原因及如何避免,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java 分析java死锁 死锁是两个线程或多个线程永远被阻塞的编程情况,这种情况发生在至少两个线程和两个或更多...Java死锁示例 package com.journaldev.threads; public class ThreadDeadlock { public static vo...
  • 死锁是两个或多个线程永远被阻塞的编程情况,这种情况发生在至少两个线程和两个或更多资源的情况下。...Java死锁示例 package com.journaldev.threads; public class ThreadDeadlock { public static void main(Str...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 26,185
精华内容 10,474
关键字:

java死锁代码示例

java 订阅