Java并发编程：Lock接口

在之前阻塞队列的底层源码中，有一个ReentrantLock类的锁来控制访问，并且有两个Condition类的条件对象(notEmpty和notFull)用来存放阻塞进程。ReentrantLock类其实是Lock接口的实现类。

一、synchronized的不足之处

JVM提供了synchronized关键字来实现对变量的同步访问以及用wait和notify来实现线程间通信。如果一个代码块被synchronized修饰了，当一个线程获取了对应的锁，并执行该代码块时，其他线程便只能一直等待，等待获取锁的线程释放锁，而这里获取锁的线程释放锁只会有两种情况：

获取锁的线程执行完了该代码块，然后线程释放对锁的占有；
线程执行发生异常，此时JVM会让线程自动释放锁。

如果这个获取锁的线程由于要等待IO或者其他原因（比如调用sleep方法）被阻塞了，但是又没有释放锁，其他线程便只能等着，这将会大大影响程序执行效率。而Lock可以不让等待的线程一直无期限地等待下去（比如只等待一定的时间或者能够响应中断）。

在比如说，当有多个线程读写文件时，读操作和写操作会发生冲突现象，写操作和写操作会发生冲突现象，但是读操作和读操作不会发生冲突现象。采用synchronized关键字来实现同步的话，如果多个线程都只是进行读操作，所以当一个线程在进行读操作时，其他线程只能等待无法进行读操作。而Lock可以使得多个线程都只是进行读操作时，线程之间不会发生冲突。

另外，通过Lock可以知道线程有没有成功获取到锁。这个是synchronized无法办到的。

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

总的来说Lock类来实现和synchronized一样的功能，并且还提供了Condition来显示线程间通信。也就是说Lock提供了比synchronized更多的功能。

二、Lock类

Lock类位于java.util.concurrent.locks包中。

先看源码：

public interface Lock {

    void lock();

    void lockInterruptibly() throws InterruptedException;

    boolean tryLock();

    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;

    void unlock();

    Condition newCondition();
}

Lock类实际上是一个接口，lock()、tryLock()、tryLock(long time, TimeUnit unit)和lockInterruptibly()是用来获取锁的。unLock()方法是用来释放锁的。

Lock类有唯一的实现类ReentrantLock

1、lock()方法

由于在前面讲到如果采用Lock，必须主动去释放锁，并且在发生异常时，不会自动释放锁。因此一般来说，使用Lock必须在try{}catch{}块中进行，并且将释放锁的操作放在finally块中进行，以保证锁一定被被释放，防止死锁的发生。我们在实例化的时候实际上是实例化实现了该接口的类Lock lock = new ReentrantLock();

就拿ArrayBlockingQueue中的offer方法举例子吧


public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        lock.lock();
        try {
            if (count == items.length)
                return false;
            else {
                insert(e);
                return true;
            }
        } finally {
            lock.unlock();
        }
}

2、tryLock() & tryLock(long time, TimeUnit unit)

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

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

我们可以试着重写下ArrayBlockingQueue中的offer方法

public boolean offer(E e) {
        checkNotNull(e);
        final ReentrantLock lock = this.lock;
        
        if(lock.tryLock()){    
            try {
                if (count == items.length)
                    return false;
                else {
                    insert(e);
                    return true;
                }
            } finally {
                lock.unlock();
            }
        }else{
            //do something
        }
}

3、lockInterruptibly()方法

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

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

public void method() throws InterruptedException {
    lock.lockInterruptibly();
    try {  
        //try something
    }
    finally {
        lock.unlock();
    }  
}

注意，当一个线程获取了锁之后，是不会被interrupt()方法中断的。调用interrupt()方法不能中断正在运行过程中的线程，只能中断阻塞过程中的线程。因此当通过lockInterruptibly()方法获取某个锁时，如果不能获取到，只有进行等待的情况下，是可以响应中断的。

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

Lock类加锁是对象锁。针对同一个lock对象执行的lock.lock是获得对象监视器的线程才能执行同步代码其他线程都要等待。

方法总结：

方法名称	描述
lock	获取锁，如果锁无法获取，那么当前的线程就变为不可被调度，直到锁被获取到
lockInterruptibly	获取锁，除非当前线程被中断。如果获取到了锁，那么立即返回，如果获取不到，那么当前线程变得不可被调度，一直休眠直到下面两件事情发生： 1、当前线程获取到了锁 2、其他的线程中断了当前的线程
tryLock	如果调用的时候能够获取锁，那么就获取锁并且返回true，如果当前的锁无法获取到，那么这个方法会立刻返回false
tryLcok(long time,TimeUnit unit)	在指定时间内尝试获取锁如果可以获取锁，那么获取锁并且返回true，如果当前的锁无法获取，那么当前的线程变得不可被调度，直到下面三件事之一发生： 1、当前线程获取到了锁 2、当前线程被其他线程中断 3、指定的等待时间到了
unlock	释放当前线程占用的锁
newCondition	返回一个与当前的锁关联的条件变量。在使用这个条件变量之前，当前线程必须占用锁。调用Condition的await方法，会在等待之前原子地释放锁，并在等待被唤醒后原子的获取锁

三、多线程如何正确上锁

Lock类除了lock和unlock方法，还提供了丰富的加锁的方法和对加锁的情况判断。

ReentrantLock，意思是“可重入锁”。ReentrantLock是唯一实现了Lock接口的类。

细心的朋友可能会注意到阻塞队列的源码中ReentrantLock类的对象是一个属性，而不是在每一个方法中新建对象，就这涉及到局部变量的问题。关于如何正确使用lock类可以看下面的例子

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    public static void main(String[] args)  {
        final Test test = new Test();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  
     
    public void insert(Thread thread) {
        Lock lock = new ReentrantLock();    
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}

运行结果

第二个线程怎么会在第一个线程释放锁之前得到了锁？原因在于，在insert方法中的lock变量是局部变量，每个线程执行该方法时都会保存一个副本，那么理所当然每个线程执行到lock.lock()处获取的是不同的锁，所以就不会发生冲突。

这也就更加验证了lock是对象锁，两个Thread类对应两个锁。

只需要将lock声明为类的属性即可

public class Test {
    private ArrayList<Integer> arrayList = new ArrayList<Integer>();
    private Lock lock = new ReentrantLock();    
    public static void main(String[] args)  {
        final Test test = new Test();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
         
        new Thread(){
            public void run() {
                test.insert(Thread.currentThread());
            };
        }.start();
    }  
     
    public void insert(Thread thread) {
        lock.lock();
        try {
            System.out.println(thread.getName()+"得到了锁");
            for(int i=0;i<5;i++) {
                arrayList.add(i);
            }
        } catch (Exception e) {
            // TODO: handle exception
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }
}

运行结果

关于ReentrantLock类和Condition类会在之后谈到

参考资料

1、https://www.cnblogs.com/dolphin0520/p/3923167.html

2、https://www.cnblogs.com/qifengshi/p/6354890.html

3、https://blog.csdn.net/weixin_39910081/article/details/80147754