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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 庄生晓梦 中级黑马   /  2012-12-5 16:56  /  1818 人查看  /  4 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

class Test2 implements Runnable
{
       
        private boolean flag;       

        Test2(boolean flag)
        {
                this.flag = flag;
                }
        public void run()
        {
                if(flag)
                {
                        while(true)
                        {
                        synchronized(MyLock.locka)
                        {
                                System.out.println("if locka");
                                synchronized(MyLock.lockb)
                                {
                                        System.out.println("if lockb");
                                }
                        }
                        }
                }
                else
                {
                        while(true)
                        {
                        synchronized(MyLock.lockb)
                        {
                                System.out.println("else lockb");
                                synchronized(MyLock.locka)
                                {
                                        System.out.println("else locka");
                                }
                        }
                        }
                }
        }
}
class MyLock
{
        static Object locka = new Object();
        static Object lockb = new Object();
       
}
public class DeadLock {
        public static void main(String[] args)
        {
               
                Thread t1 = new Thread(new Test2(true));
                Thread t2 = new Thread(new Test2(false));
                t1.start();
                t2.start();
        }
}
除类中定义MyLock类,如何使用对象级别实现死锁???????求代码

评分

参与人数 1技术分 +1 收起 理由
古银平 + 1 神马都是浮云

查看全部评分

4 个回复

倒序浏览
我看到有个总结好简单的,看这下。
  1. synchronized(a){  
  2.        ...//1  
  3.         synchronized(b){  
  4.    
  5.        }  
  6. }  
  7.    
  8. synchronized(b){  
  9.        ...//2  
  10.        synchronized(a){  
  11.    
  12.        }  
  13. }  
复制代码
回复 使用道具 举报
你可以试试这个;我只是是定义了两个String对象,对他们用锁也可死锁。其他的没有试过。
  1. /*
  2. * 线程死锁的测试
  3. * 需求:写出一个会造成死锁的多线程。
  4. * 方案:当线程1锁定了resource1时,再去试图锁定resource2.(此时,线程2可能锁定了resource2)
  5. *                 当线程2锁定了resource2时,再去试图锁定resource1.(此时,线程1可能锁定了resource1)
  6. * 1两个线程类。继承Runnable接口。
  7. * 2构造函数,接收两个资源:resource1 处resource2
  8. * 3并实现其run方法。并且方法内执行对两个资源同步锁:synchronized
  9. * 4为体现效果,让线程休眠若干秒。
  10. */
  11. class TestDeadThread {
  12.         public static void main(String[] args) {
  13.                  String resource1 = "resource1";
  14.                  String resource2 = "resource2";

  15.                 Thread thread1 = new Thread(new Thread1(resource1, resource2));
  16.                 Thread thread2 = new Thread(new Thread2(resource1, resource2));
  17.                 thread1.start();
  18.                 thread2.start();

  19.         }
  20. }

  21. /*
  22. * 线程1
  23. */
  24. class Thread1 implements Runnable {
  25.         String resource1;
  26.         String resource2;

  27.         Thread1(String r1, String r2) {
  28.                 resource1 = r1;
  29.                 resource2 = r2;
  30.         }

  31.         @Override
  32.         public void run() {
  33.                 //
  34.                 synchronized (resource1) {
  35.                         System.out.println("1锁住resource1===");
  36.                         synchronized (resource2) {//锁定resource1的同时,试图要锁定resource2
  37.                                
  38.                                         while(true){
  39.                                                 System.out.println("1锁住resource2");
  40.                                        
  41.                                         try {
  42.                                                 Thread.sleep(100);
  43.                                         } catch (InterruptedException e) {
  44.                                                 e.printStackTrace();
  45.                                         }
  46.                                 }
  47.                         }
  48.                 }
  49.         }

  50. }

  51. /*
  52. * 线程2
  53. */
  54. class Thread2 implements Runnable {
  55.         String resource1;
  56.         String resource2;

  57.         Thread2(String r1, String r2) {
  58.                 resource1 = r1;
  59.                 resource2 = r2;
  60.         }

  61.         @Override
  62.         public void run() {
  63.                 //
  64.                 synchronized (resource2) {
  65.                         System.out.println("2锁住resource2");
  66.                         synchronized (resource1) {//锁定resource2的同时,试图要锁定resource1
  67.                                 System.out.println("2锁住resource1===");
  68.                         }
  69.                 }

  70.         }

  71. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
古银平 + 1 神马都是浮云

查看全部评分

回复 使用道具 举报
多谢了!
回复 使用道具 举报
class A extends Thread
{
        public void run(){
                synchronized(A.class){
                        try{Thread.sleep(10);}catch(Exception e){}
                        synchronized(B.class){
               
                        }
                }
        }
}
class B extends Thread
{
        public void run(){
                synchronized(B.class){
                        try{Thread.sleep(10);}catch(Exception e){}
                        synchronized(A.class){
               
                        }
                }
        }
}
public class ThreadDemo
{
        public static void main(String[] args){
                A a = new A() ;
                B b = new B() ;

                a.start() ;
                b.start() ;
        }
}
这是一个最简单死锁,其实编写死锁代码只会出现在面试中,没有哪个程序员会在项目中故意写个死锁,那是自找麻烦,所以以后我们应该避免死锁,死锁只需要理解原理就行。。。。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马