A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 腹黑生姜 中级黑马   /  2015-7-1 09:19  /  1203 人查看  /  9 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 腹黑生姜 于 2015-7-1 10:00 编辑

最好用代码体现!

评分

参与人数 1技术分 +1 收起 理由
lwj123 + 1

查看全部评分

9 个回复

倒序浏览
  1. public class DeadLock implements Runnable {

  2.         boolean flag;
  3.         public DeadLock(boolean flag) {
  4.                 this.flag = flag;
  5.         }
  6.         //相互持锁,互不释放,产生死锁
  7.         public void run() {
  8.                 while(true){
  9.                         if(flag){
  10.                                 synchronized(MyLock.lock1){
  11.                                         System.out.println("true lock1");
  12.                                         synchronized (MyLock.lock2) {
  13.                                                 System.out.println("false lock2");
  14.                                         }
  15.                                 }       
  16.                         }else{
  17.                                 synchronized(MyLock.lock2){
  18.                                         System.out.println("false lock2");
  19.                                         synchronized(MyLock.lock1){
  20.                                                 System.out.println("false lock1");
  21.                                         }
  22.                                 }
  23.                         }

  24.                 }
  25.                
  26.         }
  27. }
复制代码


回复 使用道具 举报
  1. public class DieLock extends Thread {
  2.         private boolean flag;
  3.         public DieLock(boolean flag)//提供构造函数
  4.         {
  5.                 this.flag=flag;
  6.         }
  7.         //重写run方法
  8.         public void run()
  9.         {
  10.                 if(flag)//根据DieLockDemo生成的俩个线程,flag有两个值
  11.                 {
  12.                         synchronized(MyLock.objA)//线程A进来了
  13.                         {
  14.                                 System.out.println("if ObjA");
  15.                                 //此时需要线程B的锁
  16.                                 synchronized (MyLock.objB) {
  17.                                         System.out.println("if ObjB");
  18.                                        
  19.                                 }
  20.                         }
  21.                 }
  22.                 else
  23.                 {
  24.                         synchronized(MyLock.objB)//线程B进来了
  25.                         {
  26.                                 System.out.println("else ObjA");
  27.                                 //此时需要线程A的锁
  28.                                 synchronized (MyLock.objA) {
  29.                                         System.out.println("else ObjB");
  30.                                        
  31.                                 }
  32.                         }
  33.                 }
  34.         }

  35. }
  36. public class DieLockDemo {
  37.         public static void main(String[] args) {
  38.                 //建立两个个线程
  39.                 DieLock d1=new DieLock(true);
  40.                 DieLock d2=new DieLock(false);
  41.                 d1.start();
  42.                 d2.start();
  43.                
  44.         }
  45.        
  46. }
  47. public class MyLock {
  48.         //生成两个锁对象
  49.       public static final Object objA=new Object();
  50.       public static final Object objB=new Object();
  51. }
复制代码

就好比,你有两个抽屉A,B,A的钥匙锁在B抽屉里,B的钥匙锁在A抽屉里面,这不就死锁了吗
回复 使用道具 举报 1 0
死锁就是两个线程互相等待 A线程在等待B线程执行结束 B线程在等待A线程执行结束 互相等待 然后永远等不完
回复 使用道具 举报
喔哦~~这么一看,顿时茅塞顿开呀,谢谢
回复 使用道具 举报
大概就是你的不给我,我的不给你,然后就僵在那里了
回复 使用道具 举报
学习了!!!
回复 使用道具 举报
Java线程死锁是一个经典的多线程问题,因为不同的线程都在等待那些根本不可能被释放的锁,从而导致所有的工作都无法完成。假设有两个线程,分别代表两个饥饿的人,他们必须共享刀叉并轮流吃饭。他们都需要获得两个锁:共享刀和共享叉的锁。
假如线程 “A”获得了刀,而线程“B”获得了叉。线程“A”就会进入阻塞状态来等待获得叉,而线程“B”则阻塞来等待“A”所拥有的刀。这只是人为设计的例子,但尽管在运行时很难探测到,这类情况却时常发生。
导致死锁的根源在于不适当地运用“synchronized”关键词来管理线程对特定对象的访问。
避免死锁的一个通用的经验法则是:当几个线程都要访问共享资源A、B、C时,保证使每个线程都按照同样的顺序去访问它们,比如都先访问A,在访问B和C。
  此外,Thread类的suspend()方法也很容易导致死锁,因此这个方法已经被废弃了.
回复 使用道具 举报
我感觉这个好难哦,继续努力
回复 使用道具 举报
代码:
/*
需求:
死锁来一发

*/

class DeadLockDemo2
{
        public static void main(String[] args) throws InterruptedException
        {
                Thread t1 = new Thread(new Test(true));
                Thread t2 = new Thread(new Test(false));

                t1.start();
                t1.sleep(10);
                t2.start();
        }
       
        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
}

class MyLock
{
        static Object locka = new Object();
        static Object lockb = new Object();
}

class Test implements Runnable
{
        private boolean flag;

        Test(boolean flag)
        {
                this.flag = flag;
        }

        public void run()
        {
                if (flag == true)
                {
                        while (true)
                        {
                                synchronized(MyLock.locka)
                                {
                                        sop("true&locka");
                                        synchronized(MyLock.lockb)
                                        {
                                                sop("true&lockb");
                                        }
                                }
                        }
                }
                else
                {
                        while (true)
                        {
                                synchronized(MyLock.lockb)
                                {
                                        sop("false&lockb");
                                        synchronized(MyLock.locka)
                                        {
                                                sop("false&locka");
                                        }
                                }
                        }
                }
        }

        public static void sop(Object obj)
        {
                System.out.println(obj);
        }
}

死锁的意思是:
在两条线程都持有一个锁 而且程序运行都需要对方的锁的时候 程序就会卡住

这是当出现同步嵌套的时候 可能会出现的一种情况
因为可能出现一方将两个锁都用完 然后cpu执行权被另一方抢到的情况 所以同步嵌套只是前提 不是发生死锁的必要条件
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马