博客

Lock死锁的案例

死锁：线程A和线程B相互等待对方持有的锁导致程序无限死循环下去

（1）两个线程里面分别持有两个Object对象：lock1和lock2。这两个lock作为同步代码块的锁；

（2）线程1的run（）方法中同步代码块先获取lock1的对象锁，Thread.sleep(xxx)，然后接着获取lock2的对象锁。这么做主要是为了防止线程1启动一下子就连续获得了lock1和lock2两个对象的对象锁

（3）线程2的run（）方法中同步代码块先获取lock2的对象锁，接着获取lock1的对象锁，当然这时lock1的对象锁已经被线程1锁持有，线程2肯定是要等待线程1释放lock1的对象锁的

public class DeadLock
{
    private final Object lock1 = new Object()；
    private final Object lock2 = new Object()；
    
    public void Lock1() throws Exception
    {
        synchronized (lock1)
        {
            Thread.sleep(100);
            synchronized (lock2)
            {
	                System.out.println("111 end!");
            }
        }
    }
    
		    public void Lock2() throws Exception
    {
        synchronized (lock2)
        {
            Thread.sleep(100);
            synchronized (lock1)
            {
                System.out.println("222 end!");
            }
        }
    }
}

public class Thread0 extends Thread
{
    private DeadLock dl;
    
    public Thread0(DeadLock dl)
    {
        this.dl = dl;
    }
    
    public void run()
    {
        try
        {
            dl.Lock1();
        } 
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

public class Thread1 extends Thread
{
    private DeadLock dl;
    
    public Thread1(DeadLock dl)
    {
        this.dl = dl;
    }
    
    public void run()
    {
        try
        {
            dl.Lock2();
        } 
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args)
{
    DeadLock dl = new DeadLock();
    Thread0 t0 = new Thread0(dl);
    Thread1 t1 = new Thread1(dl);
    t0.start();
    t1.start();

    while(true);   
}