显式锁（一）

中秋节，漫漫长夜，岂能虚度。。。不睡了，爬起来写点啥吧

线程安全控制策略中，之前介绍了synchronized关键字，它出现在Java5.0之前。在Java5.0中，增加了新的Lock接口也可以实现锁的功能。Lock的功能和synchronized的功能相似，只是synchronized是Java的内置特性，在JVM层面实现了对临界资源的同步访问，隐式地获取锁和释放锁，而Lock在使用时需要显式地获取和释放锁，比synchronized灵活，比如响应中断、得知线程是否成功获取锁等，但是需要记得使用完lock要释放，不释放可能会死锁。
Lock在java.util.concurrent.locks包下，除Lock外，还有队列同步器、重入锁、读写锁等，下面就简单介绍一下。

1、Lock接口

public interface Lock {
    //获取锁
    void lock();
    //可中断地获取锁，与lock()的区别就是该方法在锁获取中可中断当前线程
    void lockInterruptibly() throws InterruptedException;
    //尝试非阻塞获取锁，调用方法后立刻返回，获取返回true,否则返回false
    boolean tryLock();
    //超时获取锁，三种情况下返回:①当前线程在超时时间内获得锁②当前线程在超时时间内被中断③超时时间结束，返回false
    boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
    //释放锁
    void unlock();
    //获取等待通知组件，该组件和当前的锁绑定
    Condition newCondition();
}

上面提到使用Lock，需手动释放锁，但在发生异常时，不会自动释放锁。所以，使用lock要在try{}中进行，释放锁要在finally中进行，保证锁一定被释放。

Lock lock = ……;
lock.lock();
try{
     //处理任务
}catch(Exception e){
  
}finally{
     //释放锁
     lock.unlock();
}

tryLock()是有返回值的，尝试获取锁，成功返回true,失败返回false,会立即返回，而不是在拿不到锁时傻等着。

Lock lock = ……;
if(lock.tryLock()){
    //获取锁
    try{
         //处理任务
    }catch(Exception e){

    }finally{
          //释放锁
          lock.unlock();
    }
}else{
     //没获取锁
}

lockInterruptibly(),使用此方法获取锁，可中断当前线程。如果线程正在等待获取锁，则这个线程能够相应中断。比如，两个线程A，B同时调用lock.lockInterruptibly()获取锁，如果A成功获取到锁，B只有等待，对线程B调用interrupt()就能中断B的等待过程。如果线程已经获取了锁，不会被interrupt()中断。因为interrupt()不能中断运行中的线程，只能中断阻塞线程。但是用synchronized，当一个线程处于等待状态，无法中断，只能一直等着。

2、ReentrantLock

public class ReentrantLock implements Lock, java.io.Serializable {
     //省略
}

重入锁，实现了Lock接口，意思就是该锁支持一个线程对资源的重复加锁，当一个线程获取锁后能够再次获取锁而不会被锁阻塞。重入锁分为公平和非公平。

以上都是Lock接口的几个方法的介绍，下面通过案例测试下:

① lock()

public class Test9 {
    Lock lock = new ReentrantLock();

    public void insert(Thread thread){
        lock.lock();
        try {
            System.out.println(thread.getName()+"获取了锁");

        }catch (Exception e){
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        final Test9 test9 = new Test9();

        new Thread(){
            public void run(){
                test9.insert(Thread.currentThread());
            }
        }.start();

        new Thread(){
            public void run(){
                test9.insert(Thread.currentThread());
            }
        }.start();
    }

}

运行结果：

获取一次锁，释放一次锁

将上例Test9中的insert(Thread thread)修改如下:

public void insert(Thread thread){
        lock.lock();
        lock.lock();
        try {
            System.out.println(thread.getName()+"获取了锁");

        }catch (Exception e){
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
        }
}

运行结果：

获取两次锁，释放一次锁

可以看到另一个线程一直处于阻塞状态，这是因为Lock接口实现的是可重入锁，线程进行了两次获取锁，却只执行了一次释放锁，所以所并没有彻底释放。

重入锁的最终释放

线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放。

所以，两次获取锁需要两次释放锁，insert方法修改如下即可：

public void insert(Thread thread){
        lock.lock();
        lock.lock();
        try {
            System.out.println(thread.getName()+"获取了锁");

        }catch (Exception e){
        }finally {
            System.out.println(thread.getName()+"释放了锁");
            lock.unlock();
            lock.unlock();
        }
}

两次获取锁，两次释放锁

② tryLock()

public class Test9 {
    Lock lock = new ReentrantLock();

    public void insert(Thread thread){
        if(lock.tryLock()){
            try {
                System.out.println(thread.getName()+"获取了锁");
            }catch (Exception e){
            }finally {
                System.out.println(thread.getName()+"释放了锁");
                lock.unlock();
            }
        }else{
            System.out.println(thread.getName()+"获取锁失败");
        }
    }

    public static void main(String[] args) {
        final Test9 test9 = new Test9();

        new Thread(){
            public void run(){
                test9.insert(Thread.currentThread());
            }
        }.start();

        new Thread(){
            public void run(){
                test9.insert(Thread.currentThread());
            }
        }.start();
    }

}

可以看出，Thread-0使用tryLock()成功获取锁后，Thread-1使用tryLock()尝试非阻塞地获取锁，获取失败，立即返回，返回了false。

③ lockInterruptibly()

public class MyThead  implements Runnable{
    private static Lock lock = new ReentrantLock();
    @Override
    public void run() {
        try {
            ddd();
        } catch (InterruptedException e) {
            System.out.println(Thread.currentThread().getName()+" 线程中断");
        }
    }

    private void ddd() throws InterruptedException{
        lock.lockInterruptibly();
        System.out.println(Thread.currentThread().getName()+" 获得了锁");
        try{
            System.out.println(Thread.currentThread().getName() + " running");
            TimeUnit.SECONDS.sleep(3);
            System.out.println(Thread.currentThread().getName() + " finished");

        }catch(InterruptedException e){
            System.out.println(Thread.currentThread().getName() + " interrupted");
        }finally{
            lock.unlock();
        }
    }

}

public class Test10 {
    public static void main(String[] args) throws Exception {
        Thread t1 = new Thread(new MyThead());
        Thread t2 = new Thread(new MyThead());

        t1.start();
        t2.start();
        t2.interrupt();
    }
}

运行结果：

可以看出，lockInterruptibly()允许在等待时由其他线程的Thread.interrupt()方法来中断等待线程而直接返回，这时是不用获取锁的，而会抛出一个InterruptException。

将MyThead——>ddd()方法中的"lock.lockInterruptibly();"修改为"lock.lock();"，再次运行，运行结果：

可以看出，lock()方法则不允许Thread.interrupt()中断，即使检测到了Thread.interruptted一样会继续尝试获取锁，失败则继续休眠。

3、ReadWriteLock

public interface ReadWriteLock {
    /**
     * Returns the lock used for reading.
     *
     * @return the lock used for reading
     */
    Lock readLock();

    /**
     * Returns the lock used for writing.
     *
     * @return the lock used for writing
     */
    Lock writeLock();
}

ReadWriteLock是个接口，定义了两个方法，readLock来获取读锁，writeLock来获取写锁。将文件的读写操作分开，两个锁分别分配给线程，能使多个线程同时进行读操作。

4、ReentrantReadWriteLock

ReentrantReadWriteLock实现了ReadWriteLock接口。
分别启动两个线程，第一种方式是通过synchronized来实现，第二种方式通过读写锁完成。

public class Test10 {
    public static void main(String[] args) throws Exception {
        final Test10 test = new Test10();
        new Thread(){
            public void run(){
                test.get(Thread.currentThread());
            }
        }.start();

        new Thread(){
            public void run(){
                test.get(Thread.currentThread());
            }
        }.start();
    }

    public  void get(Thread thread){
        for(int i = 0 ; i < 50; i++){
            System.out.println(thread.getName()+"正在进行读操作");
        }
        System.out.println(thread.getName()+"读操作完毕");
    }
}

直到Thread-0执行完读操作之后，才会打印Thread-1执行读操作的信息。

public class Test10 {
    private ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    public static void main(String[] args) throws Exception {
        final Test10 test = new Test10();
        new Thread(){
            public void run(){
                test.get(Thread.currentThread());
            }
        }.start();

        new Thread(){
            public void run(){
                test.get(Thread.currentThread());
            }
        }.start();
    }

    public void get(Thread thread){
        rwl.readLock().lock();
        try {
            for(int i = 0 ; i < 50; i++){
                System.out.println(thread.getName()+"正在进行读操作");
            }
            System.out.println(thread.getName()+"读操作完毕");
        }finally {
            rwl.readLock().unlock();
        }

    }
}

Thread-0和Thread-1交替执行，提高了读操作的效率。
不过要注意的是，如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待释放读锁。如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，则申请的线程会一直等待释放写锁。

总结

本篇主要介绍了Lock接口、ReadWriteLock接口、ReentrantLock、ReentrantReadWriteLock的基础用法。
Lock和synchronized的区别：①Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现；②synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；③Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；④通过Lock可以知道有没有成功获取锁，而synchronized却无法办到；⑤Lock可以提高多个线程进行读操作的效率。在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。

本篇参考了《并发编程的艺术》，需要深入了解的同学可以阅读书籍《并发编程的艺术》、《并发编程实战》。

略陈固陋，如有不当之处，欢迎各位看官批评指正！