JAVA初级(二十八)多线程(4)死锁的形成与Lock接口基本使用

死锁出现原因

public class Goods implements Runnable{
    private int num = 0;
   final Object obj1 = new Object();//锁1
   final Object obj2 = new Object();//锁2
    @Override
    public void run() {
       while (true){
           if(num%2==0){
           //嵌套使用同步锁
               synchronized (obj1){
                   System.out.println(Thread.currentThread().getName()+":拿到obj1-输出Y1");
                   synchronized (obj2){
                       System.out.println(Thread.currentThread().getName()+":拿到obj2-输出Y2");
                   }
               }
           }else {
               synchronized (obj2){
                   System.out.println(Thread.currentThread().getName()+":拿到obj2-输出N1");
                   synchronized (obj1){
                       System.out.println(Thread.currentThread().getName()+":拿到obj1-输出N2");
                   }
               }
           }
           num++;
       }
    }
}

如果编写了类似上述的嵌套同步锁代码
此时创建两个线程执行

public static void main(String[] args)  {
        Goods goods = new Goods();
        Thread thread1 = new Thread(goods);
        Thread thread2 = new Thread(goods);
        thread1.start();
        thread2.start();
    }

结果输出如下:
Thread-0:拿到obj1-输出Y1
Thread-0:拿到obj2-输出Y2
Thread-0:拿到obj2-输出N1
Thread-1:拿到obj1-输出Y1

正常情况应该会无限输出。但实际就只输出了这么点就停住了。说明出现了死锁导致程序阻塞.

分析执行过程:
Thread-0先启动执行线程,此时全局的num=0所以执行if(true),然后拿到obj1锁执行同步代码块,但是时间很短.此时Thread-1也启动然后抢到资源并执行线程,此时num仍然为0,然后执行if(true),发现没有obj1锁于是等待.然后thread-0继续执行obj1的代码块输出后,在拿到嵌套的obj2,继续输出。接着释放obj2,在释放obj1并执行num++。obj1释放后，Thread-1就拿到obj1,拿到锁后Thread-0再次抢到资源,此时num=1,执行if(false),然后拿到obj2锁并输出,然后继续执行发现没有obj1锁,于是等待。接着Thread-1继续执行,然后发现没有obj2锁于是等待。最终两个线程就陷入了无限等待形成死锁。

到这,死锁的形成过程就说完了
可以发现造成死锁的原因之一就是嵌套使用了synchronized同步锁。所以想要避免死锁就要分析这部分代码是否需要使用嵌套同步锁。如果不需要就不使用就能避免死锁。如果需要使用嵌套同步锁那就具体情况具体分析。比如上面这个例子,把if(false)的代码的obj2和obj1换个位置就能避免死锁

Lock接口

Lock接口也能实现同步,并且能够更灵活的对线程进行同步操作,Lock接口有好几个实现类和很多方法。这把先介绍最基本的两个方法就是Lock实现类ReentrantLock的lock()和unlock()方法
lock():获取锁
unlock():释放锁

即:

synchronized(obj){
	//代码块
}

相当于

lock();
代码块
unlock();

不过要注意的是synchronized代码块在出异常的情况会自动释放锁,lock则不会。因此需要在try里面执行.
即lock应该这样用

lock();
try{
//代码
}finally{
unlock()
}

简单编写一个lock代码

public class Goods implements Runnable{
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        lock.lock();
        try{
            System.out.println("同步代码");
        }
        finally {
            lock.unlock();
        }
    }
}

即相当于

public class Goods implements Runnable{
    final Object obj= new Object();
    @Override
    public void run() {
       synchronized (obj){
           System.out.println("同步代码块");
       }
    }
}

到这Lock接口的基本使用就说完了

需要注意的是,选择Lock实现同步时,要用try然后在finally释放锁,总之就是要保证释放锁。否则容易导致死锁

总结:
1,死锁的形成
(1)同步嵌套使用synchronized可能导致死锁
(2)使用lock接口没有手动释放锁。容易导致死锁
2,lock接口基本使用
使用ReentrantLock实现类的lock()和unlock()方法来实现同步