Lock接口获取锁的四个方法lock，tryLock，lockInterruptibly实例

原文链接：https://blog.csdn.net/qichangjian/java/article/details/88122419

Lock接口获取锁的四个方法lock，tryLock，lockInterruptibly实例

Lock和synchronized的比较？

Lock提供了比synchronized更多的功能。但是要注意以下几点：

1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；

2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

Lock接口

首先要说明的就是Lock，通过查看Lock的源码可知，Lock是一个接口：

public interface Lock {

void lock();//阻塞方法   阻塞的时间：另外一个线程释放锁

void lockInterruptibly() throws InterruptedException;//使锁具备可被中断的能力,防止死等,中断在等待中的锁

boolean tryLock();//非阻塞方法,试图获取锁的方法 (线程启动的时候会尝试的获取锁获取到---true 获取不到--false)

boolean tryLock(long time, TimeUnit unit) throws InterruptedException;//试图获取锁的方法 (参数1：参数时间大小, 参数2：时间单位)

//阻塞方法阻塞的时间就是参数的时间

//参数的时间内获取到了---true 获取不到---false

    void unlock();

    Condition newCondition();

}

下面来逐个讲述Lock接口中每个方法的使用， lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly() 是用来获取锁的。unLock()方法是用来释放锁的

四种实现详解

在Lock中声明了四个方法来获取锁，那么这四个方法有何区别呢？

1.lock()

首先lock()方法是平常使用得最多的一个方法，就是用来获取锁。如果锁已被其他线程获取，则进行等待。

由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。通常使用Lock来进行同步的话，是以下面这种形式去使用的：

Lock lock = new ReentrantLock();

lock.lock();

try{

//处理任务

}catch(Exception ex){

}finally{

lock.unlock(); //释放锁

}

2.tryLock()

tryLock()方法是有返回值的，它表示用来尝试获取锁，如果获取成功，则返回true，如果获取失败（即锁已被其他线程获取），则返回false，也就说这个方法无论如何都会立即返回。在拿不到锁时不会一直在那等待。

3.tryLock(long time, TimeUnit unit)

tryLock(long time, TimeUnit unit)方法和tryLock()方法是类似的，只不过区别在于这个方法在拿不到锁时会等待一定的时间，在时间期限之内如果还拿不到锁，就返回false。如果如果一开始拿到锁或者在等待期间内拿到了锁，则返回true。

所以，一般情况下通过tryLock来获取锁时是这样使用的：

Lock lock = ...;

if(lock.tryLock()) {

     try{

         //处理任务

     }catch(Exception ex){

     }finally{

         lock.unlock();   //释放锁

     }

}else {

    //如果不能获取锁，则直接做其他事情

}

4.lockInterruptibly()

lockInterruptibly()方法比较特殊，当通过这个方法去获取锁时，如果线程正在等待获取锁，则这个线程能够响应中断，即中断线程的等待状态。也就使说，当两个线程同时通过lock.lockInterruptibly()想获取某个锁时，假若此时线程A获取到了锁，而线程B只有在等待，那么对线程B调用**threadB.interrupt()**方法能够中断线程B的等待过程。

由于lockInterruptibly()的声明中抛出了异常，所以lock.lockInterruptibly()必须放在try块中或者在调用lockInterruptibly()的方法外声明抛出InterruptedException。

因此lockInterruptibly()一般的使用形式如下：

public void method() throws InterruptedException {

    lock.lockInterruptibly();

    try {

     //.....

    }

    finally {

        lock.unlock();

    }

}

注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。因为本身在前面的文章中讲过单独调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。

因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

而用synchronized修饰的话，当一个线程处于等待某个锁的状态，是无法被中断的，只有一直等待下去。