ReentrantLock(重入锁)功能详解&应用演示

深入理解ReentrantLock

在Java中通常实现锁有两种方式，一种是synchronized关键字, 另一种是Lock。二者其实并没有什么必然联系,但是各有各的特点,在使用中可以进行取舍的使用。

ReentrantLock是Lock的默认实现方式之一是基于AQS(Abstrack Queued Synchronizer,队列同步器) 实现的默认是通过非公平锁实现的，它的内部有一个state的状态字段用于表示锁是否被占用，如果0则表示锁未被占用，此时线程就可以吧state改为1，并成功获得锁而其他未获得锁的线程只能去排队等待获取资源
这两个都实现了锁的功能，具备互斥性和不可见性。

**下面是ReentrantLock的UML图

JDK1.6之后synchronized性能略低于ReentrantLock

一、ReentrantLock和synchronized的相同点：

1. Renitrentoc是独占锁且可重入。

public class ReentrantLockTest {

    public static void main(String[] args) throws InterruptedException {

        ReentrantLock lock = new ReentrantLock();

        for (int i = 1; i <= 10; i++) {
            lock.lock();
        }

        for(int i=1;i<=10;i++){
            try {

            } finally {
                lock.unlock();
            }
        }
    }
}

上面的代码通过lock() 方法先获取锁10次，然后通过un1ock()
方法释放锁10次,程序可以正常退出。从上面的例子可以看出
ReentrantLock 是可以重入的锁,当-个线程获取锁时，还可以接着重复获取多次。在加上ReentrantLock的的独占性。

    我们可以得出以下ReentrantLock和synchronized的相同点。

实现: ##### *

最大的不同: synchronized是基 于JVM层面实现的，而Lock是 基于JDK层面实现的。曾经反复的找过synchronized的实现，可惜最终无果。但Lock却是基于JDK实现的,我们可以通过阅读JDK的源码来理解L ock的实现。*

●1.ReentrantLock和synchronized都是独占锁只允许线程互 斥的访问临界区。但是实现上两者不同:synchronized加锁解锁的过程是隐式的，用户不用手动操作,优点是操作简单,但显得不够灵活。-般并
发场景使用synchronized的就够了; ReentrantLock需要手动加锁和解锁，且解锁的操作尽量要放在finally代码块中,保证线程正确释放锁。ReentrantLock操作较为复杂， 但是因为可以手动控制加锁和解锁过程,在复杂的并发场景中能派上用场。

●2.ReentrantLock和synchronized都是可重入的。 synchronized因为可重入因此可以放在被递归执行的方
法上,且不用担心线程最后能否正确释放锁;而ReentrantLock在 重入时要却确保重复获取锁的次数必须和重复释放锁的次数一样，否则可能导致其他线程无法获得该锁。

二、 ReentrantLock相比synchronized的额外功能

1.Reentrantlock可以实现公平锁。

公平锁是指当锁可用时，在锁上等待时间最长的线程将获得锁的使用权。而非公平锁则随机分配这种使用权。和synchronized一样,默认的ReentrantLock实现是非公平锁,因为相比公平锁，非公平锁性能更好。当然公平锁能防止饥饿,某些情况下也很有用。在创建ReentrantLock的时候通过传进参数true |创建公平锁，如果传入的是false或没传参数则创建的是非公平锁。

ReentrantLock lock = new ReentrantLock(true);

●一个公平锁的例子

public class ReentrantLockTest {

    static Lock lock = new ReentrantLock(true);

    public static void main(String[] args) throws InterruptedException {

        for(int i=0;i<5;i++){
            new Thread(new ThreadDemo(i)).start();
        }

    }

    static class ThreadDemo implements Runnable {
        Integer id;

        public ThreadDemo(Integer id) {
            this.id = id;
        }

        @Override

      public void run() {
            try {
                TimeUnit.MILLISECONDS.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            for(int i=0;i<2;i++){
                lock.lock();
                System.out.println("获得锁的线程："+id);
                lock.unlock();
            }
        }
    }
}

公平锁结果:

我们开启5个线程,让每个线程都获取释放锁两次。为了能更好的观察到结果,在每次获取锁前让线程休眠10毫秒。可以看到线程几乎是轮流的获取到了锁。如果我们改成非公平锁,再看下结果

●非公平锁结果

线程会重复获取锁。如果申请获取锁的线程足够多,那么可能会造成某些线程长时间得不到锁。这就是非公平锁的 “饥饿” 问题。

总结：
公平锁可以保证锁的获取按FIFO原则，而代价是进行大量的线程切换。非公平锁虽然可能造成线程“饥饿”，但极少的线程切换，保证了其更大的吞吐量。

三、ReentrantLock可响应中断

当使用synchronized实现锁时,阻塞在锁上的线程除非获得锁否则将- -直等待 下去，也就是说这种无限等待获取锁的行为无法被中断。而ReentrantLock给我们提供 了一一个可以响应中断的获取锁的方法lockInterruptibly() 该方法可以用来解决死锁问题。

四、获取锁时限时等待

ReentrantL ock还给我们提供了获取锁限时等待的方法| tryLock() ,可以选择传入时间参数,表示等待指定的时间,无参则表示立即返回锁申请的结果: true 表示获取锁成功 ,false 表示获取锁失败。我们可以使用该方法配合失败重试机制来更好的解决死锁问题。

public class ReentrantLockTest {
    static Lock lock1 = new ReentrantLock();
    static Lock lock2 = new ReentrantLock();
    public static void main(String[] args) throws InterruptedException {

        Thread thread = new Thread(new ThreadDemo(lock1, lock2));//该线程先获取锁1,再获取锁2
        Thread thread1 = new Thread(new ThreadDemo(lock2, lock1));//该线程先获取锁2,再获取锁1
        thread.start();
        thread1.start();
    }

    static class ThreadDemo implements Runnable {
        Lock firstLock;
        Lock secondLock;
        public ThreadDemo(Lock firstLock, Lock secondLock) {
            this.firstLock = firstLock;
            this.secondLock = secondLock;
        }
        @Override
        public void run() {
            try {
                while(!lock1.tryLock()){
                    TimeUnit.MILLISECONDS.sleep(10);
                }
                while(!lock2.tryLock()){
                    lock1.unlock();
                    TimeUnit.MILLISECONDS.sleep(10);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                firstLock.unlock();
                secondLock.unlock();
                System.out.println(Thread.currentThread().getName()+"正常结束!");
            }
        }
    }
}

结果：

五、.结合Condition实现等待通知机制

使用synchronized结合Object_上的wait和notify方法可以实现线程间的等待通知机制。ReentrantLock结合Condition接口同样可以实现这个功能。而且相比前者使用起来更清晰也更简单。

Condition由Lock对象创建,并且可以同时创建多个

static Condition notEmpty = lock.newCondition();

static Condition notFull = lock.newCondition();

Condition接口在使用前必须先调用ReentrantLock的lock()方法获得锁。之后调用Condition接口的await()将释放锁,并且在该Condition.上等待,直到有其他线程调用Condition的signal()方法唤醒线程。使用方式和wait,notify类似。

一个使用condition的简单例子

public class ConditionTest {

    static ReentrantLock lock = new ReentrantLock();
    static Condition condition = lock.newCondition();
    public static void main(String[] args) throws InterruptedException {

        lock.lock();
        new Thread(new SignalThread()).start();
        System.out.println("主线程等待通知");
        try {
            condition.await();
        } finally {
            lock.unlock();
        }
        System.out.println("主线程恢复运行");
    }
    static class SignalThread implements Runnable {

        @Override
        public void run() {
            lock.lock();
            try {
                condition.signal();
                System.out.println("子线程通知");
            } finally {
                lock.unlock();
            }
        }
    }
}

运行结果：

六、使用Condition实现简单的阻塞队列

阻塞队列是一种特殊的先进先出队列,它有以下几个特点：
1.入队和出队线程安全。
2.当队列满时，入队线程会被阻塞;当队列为空时,出队线程会被阻塞。

●阻塞队列的简单实现

public class MyBlockingQueue<E> {

    int size;//阻塞队列最大容量

    ReentrantLock lock = new ReentrantLock();

    LinkedList<E> list=new LinkedList<>();//队列底层实现

    Condition notFull = lock.newCondition();//队列满时的等待条件
    Condition notEmpty = lock.newCondition();//队列空时的等待条件

    public MyBlockingQueue(int size) {
        this.size = size;
    }

    public void enqueue(E e) throws InterruptedException {
        lock.lock();
        try {
            while (list.size() ==size)//队列已满,在notFull条件上等待
                notFull.await();
            list.add(e);//入队:加入链表末尾
            System.out.println("入队：" +e);
            notEmpty.signal(); //通知在notEmpty条件上等待的线程
        } finally {
            lock.unlock();
        }
    }

    public E dequeue() throws InterruptedException {
        E e;
        lock.lock();
        try {
            while (list.size() == 0)//队列为空,在notEmpty条件上等待
                notEmpty.await();
            e = list.removeFirst();//出队:移除链表首元素
            System.out.println("出队："+e);
            notFull.signal();//通知在notFull条件上等待的线程
            return e;
        } finally {
            lock.unlock();
        }
    }
}

●测试代码

public static void main(String[] args) throws InterruptedException {

    MyBlockingQueue<Integer> queue = new MyBlockingQueue<>(2);
    for (int i = 0; i < 10; i++) {
        int data = i;
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    queue.enqueue(data);
                } catch (InterruptedException e) {

                }
            }
        }).start();

    }
    for(int i=0;i<10;i++){
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Integer data = queue.dequeue();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

}

结果：

ReentrantLock是可重入的独占锁。比起synchronized功能更加丰富，支持公平锁实现，支持中断响应以及限时等待等等。可以配合一个或多个Condition条件方便的实现等待通知机制。

java并发编程是一个道阻且深的方向，还需不断努力！！

资料参考：
《JAVA并发编程的艺术》
《JAVA并发编程实战》
相关博客

对技术有追求。对生活有态度、