黑马程序员技术交流社区

标题: 大家看看我这个死锁的程序写的对不对啊，要疯了 [打印本页]
作者: 徐传任    时间: 2012-9-17 20:07
标题: 大家看看我这个死锁的程序写的对不对啊，要疯了
麻烦大家给看看我这个死锁的程序的写的对不对啊，我感觉没什么错误啊，可是为什么每次的执行结果都相同啊，执行了n次打印出来的结果一模一样
class DeadLock implements Runnable {
    public boolean flag = true;
    public void run() {
        if(flag) {
            while(true) {
                synchronized(Lock.locka) {
                    System.out.println(Thread.currentThread().getName()+"iflocka");
                    synchronized(Lock.lockb) {
                        System.out.println(Thread.currentThread().getName()+"iflockb");
                    }   
                }               
            }
        } else {
            while(true) {
                synchronized(Lock.lockb) {
                    System.out.println(Thread.currentThread().getName()+"........lockb");
                    synchronized(Lock.locka) {
                        System.out.println(Thread.currentThread().getName()+".........locka");
                    }   
                }               
            }
        }
    }
}

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

public class DeadLockTest1 {
    public static void main(String[] args) {
        DeadLock dl = new DeadLock();
        Thread t1 = new Thread(dl);
        Thread t2 = new Thread(dl);
        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        dl.flag = false;
        t2.start();
    }
}
死锁这块弄一晚上了，麻烦明白的学哥学姐给俺讲讲，谢谢...

作者: 史小兵    时间: 2012-9-17 20:44
在多线程中线程启动后，cpu资源的分配是随机的，可能你执行100次都会是一样的，这没什么的。但是清楚死锁的概念就好了
即一组线程都持有资源，并且等待线程中其他线程的资源。
满足一下四点死锁就会发生：
互斥：一次只有一个线程可以使用一个资源
占有并等待：一个至少持有一个资源的线程等待获得有其他线程所持有的资源
非抢占：一个线程只有等到其执行完之后才会自动释放。
循环等待：等待资源之间存在环
记住以上几点就可以了！
作者: 徐传任    时间: 2012-9-17 20:51
史小兵 发表于 2012-9-17 20:44
在多线程中线程启动后，cpu资源的分配是随机的，可能你执行100次都会是一样的，这没什么的。但是清楚死锁的 ...

那我写的那个应该是没错是吧？
作者: 程振    时间: 2012-9-17 20:51
知道理论后，下面的代码就很好写了
  1. class ThreadA extends Thread {
  2.         private Object x;
  3.         private Object y;

  5.         public ThreadA(Object x, Object y) {
  6.                 this.x = x;
  7.                 this.y = y;
  8.         }

  10.         @Override
  11.         public void run() {
  12.                 while (true) {
  13.                         synchronized (x) {
  14.                                 System.out.println("ThreadB 以获取x。。。。");
  15.                                 try {
  16.                                         sleep(3000);
  17.                                 } catch (InterruptedException e) {
  18.                                         e.printStackTrace();
  19.                                 }
  20.                                 System.out.println("ThreadA 正请求y:");
  21.                                 synchronized (y) {
  22.                                         System.out.println("ThreadA 以获取y。。。。");
  23.                                 }
  24.                                 System.out.println("ThreadA 释放y,,,,");
  25.                         }
  26.                         System.out.println("ThreadA 释放x,,,,");
  27.                 }

  29.         }
  30. }

  32. class ThreadB extends Thread {
  33.         private Object x;
  34.         private Object y;

  36.         public ThreadB(Object x, Object y) {
  37.                 this.x = x;
  38.                 this.y = y;
  39.         }

  41.         @Override
  42.         public void run() {
  43.                 while (true) {
  44.                         synchronized (y) {
  45.                                 System.out.println("ThreadB 以获取y。。。。");
  46.                                 try {
  47.                                         sleep(3000);
  48.                                 } catch (InterruptedException e) {
  49.                                         e.printStackTrace();
  50.                                 }

  52.                                 System.out.println("ThreadB 正请求x:");
  53.                                 synchronized (x) {
  54.                                         System.out.println("ThreadB 以获取x。。。。");
  55.                                 }
  56.                                 System.out.println("ThreadB 释放x,,,,");
  57.                         }
  58.                         System.out.println("ThreadB 释放y,,,,");
  59.                 }
  60.         }
  61. }

  63. public class DeadLock {
  64.         public static void main(String[] args) {
  65.                 // 建立两个对象锁
  66.                 Object x = new Object();
  67.                 Object y = new Object();
  68.                
  69.                 // ThreadA先获取x，然后获取y
  70.                 new ThreadA(x, y).start();
  71.                
  72.                 // ThreadA先获取y，然后获取x
  73.                 new ThreadB(x, y).start();
  74.                
  75.                 // synchronized关键字获取对象时，如果没有获取会一直等待查询，知道获取
  76.         }
  77. }
复制代码
作者: 徐传任    时间: 2012-9-17 20:51
我就是纳闷，难道我真就那么悲剧....
作者: 史小兵    时间: 2012-9-17 21:28
嗯，应该没问题的！或者你可以把sleep时间改的长一点试试就知道了
作者: 谭立文    时间: 2012-9-17 22:00
class DeadLock implements Runnable {
    public boolean flag = true;
    public void run() {
        if(flag) {
            while(true) {
                synchronized(Lock.locka) {
                    System.out.println(Thread.currentThread().getName()+"iflocka");
                   try {
                                                Thread.currentThread().sleep(1000);
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }                    synchronized(Lock.lockb) {
                        System.out.println(Thread.currentThread().getName()+"iflockb");
                    }   
                }               
            }
        } else {
            while(true) {
                synchronized(Lock.lockb) {
                    System.out.println(Thread.currentThread().getName()+"........lockb");
                    try {
                                                Thread.currentThread().sleep(1000);
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }                    synchronized(Lock.locka) {
                        System.out.println(Thread.currentThread().getName()+".........locka");
                    }   
                }               
            }
        }
    }
}

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

public class test {
    public static void main(String[] args) {
        DeadLock dl = new DeadLock();
        Thread t1 = new Thread(dl);
        Thread t2 = new Thread(dl);
        t1.start();
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        dl.flag = false;
        t2.start();
    }
}
作者: 黑马张涛    时间: 2012-9-17 22:09
  1. class DeadLock implements Runnable {
  2.              public boolean flag = true;
  3.              DeadLock(boolean flag)//直接在构造函数这里设置标记
  4.              {
  5.                      this.flag = flag;
  6.              }
  7.              public void run() {
  8.                  if(flag) {
  9.                      while(true) {
  10.                          synchronized(Lock.locka) {
  11.                              System.out.println(Thread.currentThread().getName()+"iflocka");
  12.                              synchronized(Lock.lockb) {
  13.                                  System.out.println(Thread.currentThread().getName()+"iflockb");
  14.                              }   
  15.                         }               
  16.                     }
  17.                  } else {
  18.                      while(true) {
  19.                          synchronized(Lock.lockb) {
  20.                              System.out.println(Thread.currentThread().getName()+"........lockb");
  21.                              synchronized(Lock.locka) {
  22.                                  System.out.println(Thread.currentThread().getName()+".........locka");
  23.                              }   
  24.                         }               
  25.                     }
  26.                  }
  27.              }
  28.          }
  29.          
  30.         class Lock {
  31.              public static Object locka = new Object();
  32.              public static Object lockb = new Object();
  33.          }
  34.          
  35.         public class DeadLockTest{
  36.              public static void main(String[] args) {
  37.                  Thread t1 = new Thread(new DeadLock(true));
  38.                  Thread t2 = new Thread(new DeadLock(false));
  39.                  t1.start();//这样t1,t2会同时去抢执行权，t1抢到a锁后，t2也拿到了b锁，然后才能发生死锁
  40.                  t2.start();
  41.              }
  42.          }
复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2