JUC-线程锁之ReentrantLock详解（三）

沉泽·

已于 2022-04-06 19:03:29 修改

阅读量590

点赞数 1

分类专栏： juc 文章标签： java 经验分享程序人生

于 2022-03-15 00:19:52 首次发布

原文链接：https://www.cnblogs.com/takumicx/p/9338983.html

版权

juc 专栏收录该内容

23 篇文章 3 订阅

订阅专栏

一、ReentrantLock简介

jdk中独占锁的实现除了使用关键字synchronized外,还可以使用ReentrantLock。虽然在性能上ReentrantLock和synchronized没有什么区别，但ReentrantLock相比synchronized而言功能更加丰富，它更灵活、更强大，增加了轮询、超时、中断等高级功能，更适合复杂的并发场景。

二、 ReentrantLock是独占锁且可重入的

例子：

public class ReentrantLockTest {

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

        ReentrantLock lock = new ReentrantLock();

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

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

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

上面的代码通过lock()方法先获取锁三次，然后通过unlock()方法释放锁3次，程序可以正常退出。从上面的例子可以看出,ReentrantLock是可以重入的锁,当一个线程获取锁时,还可以接着重复获取多次。在加上ReentrantLock的的独占性，我们可以得出以下ReentrantLock和synchronized的相同点。

1.ReentrantLock和synchronized都是独占锁,只允许线程互斥的访问临界区。但是实现上两者不同:synchronized加锁解锁的过程是隐式的,用户不用手动操作,优点是操作简单，但显得不够灵活。一般并发场景使用synchronized的就够了；ReentrantLock需要手动加锁和解锁,且解锁的操作尽量要放在finally代码块中,保证线程正确释放锁。ReentrantLock操作较为复杂，但是因为可以手动控制加锁和解锁过程,在复杂的并发场景中能派上用场。
2.ReentrantLock和synchronized都是可重入的。synchronized因为可重入因此可以放在被递归执行的方法上,且不用担心线程最后能否正确释放锁；而ReentrantLock在重入时要却确保重复获取锁的次数必须和重复释放锁的次数一样，否则可能导致其他线程无法获得该锁。

三、ReentrantLock的公平锁/非公平锁

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

3.1 公平锁/非公平锁的创建

非公平锁的创建：传入的是false或没传参数则创建的是非公平锁

ReentrantLock lock = new ReentrantLock();

ReentrantLock lock = new ReentrantLock(false);

公平锁的创建：传入的是true是公平锁

ReentrantLock lock = new ReentrantLock(true);

简单看一下该构造方法的源码就可以知道了：

/**
 * Creates an instance of {@code ReentrantLock} with the
 * given fairness policy.
 *
 * @param fair {@code true} if this lock should use a fair ordering policy
 */
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

可以看到公平锁和非公平锁的实现关键在于成员变量sync的实现不同,这是锁实现互斥同步的核心。后面我们再细讲。

3.2 公平锁/非公平锁的实现案例

代码：

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();
            }
        }
    }
}

公平锁：

static Lock lock = new ReentrantLock(true);

我们开启5个线程,让每个线程都获取释放锁两次。为了能更好的观察到结果,在每次获取锁前让线程休眠10毫秒。可以看到线程几乎是轮流的获取到了锁。运行的结果如下：
在这里插入图片描述

非公平锁：

static Lock lock = new ReentrantLock();
//static Lock lock = new ReentrantLock(false);

线程会重复获取锁。如果申请获取锁的线程足够多,那么可能会造成某些线程长时间得不到锁。这就是非公平锁的“饥饿”问题。
改成非公平锁,再看下结果：
在这里插入图片描述
非公平锁出现了一个线程持续多次获得锁的情况。因为第一次获取到锁的线程很大可能第二次仍旧获得到锁，如果你改成循环50次以上，就会发现乱了。

非公平锁出现了线程多次持续获得锁的情况，博主本人的理解：
结合AQS源码，你会发现所有阻塞的线程都会存放在一个双端队列里，队列里的线程会被依次从队列头取出拿去执行。
看到这里，你也许会疑问，那所有线程不就顺序执行了吗？非公平体现在哪？
首先线程入队的顺序是随机的，谁先抢到CPU执行片，谁就先入队。
那么入队了的线程执行顺序就决定了吗？未必，每个执行中的线程执行了unlock后又立马执行lock，而执行的lock的过程中，非公平锁下线程会尝试去抢占锁，若抢到了就接着执行，若没抢到，我再入队。而这步操作就导致了线程重新抢到锁的概率就比阻塞在队列里的线程抢的到锁的概率大一些。
这里的解释有些笼统，大家可以看这篇文章：
https://blog.csdn.net/weixin_41979002/article/details/123504649

3.3 如何选择

大部分情况下我们使用非公平锁，因为其性能比公平锁好很多。但是公平锁能够避免线程饥饿，某些情况下也很有用。

四、ReentrantLock可响应中断

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

案例：

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();
        thread.interrupt();//是第一个线程中断
    }

    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 {
                firstLock.lockInterruptibly();
                TimeUnit.MILLISECONDS.sleep(10);//更好的触发死锁
                secondLock.lockInterruptibly();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                firstLock.unlock();
                secondLock.unlock();
                System.out.println(Thread.currentThread().getName()+"正常结束!");
            }
        }
    }
}

构造死锁场景:创建两个子线程,子线程在运行时会分别尝试获取两把锁。其中一个线程先获取锁1在获取锁2，另一个线程正好相反。如果没有外界中断，该程序将处于死锁状态永远无法停止。我们通过使其中一个线程中断，来结束线程间毫无意义的等待。被中断的线程将抛出异常，而另一个线程将能获取锁后正常结束。
在这里插入图片描述

五、ReentrantLock获取锁时限时等待

5.1 tryLock()使用介绍

ReentrantLock还给我们提供了获取锁限时等待的方法tryLock()

可以选择传入时间参数,表示获取锁时允许等待的时间，该时间内获取到锁则返回true，反之返回false
无参则表示立即返回锁申请的结果:true表示获取锁成功,false表示获取锁失败。

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

        Thread thread = new Thread(new ThreadDemo());
        Thread thread1 = new Thread(new ThreadDemo());
        thread.start();
        thread1.start();
    }

    static class ThreadDemo implements Runnable {
        @Override
        public void run() {
            try {
                if(lock.tryLock(20,TimeUnit.SECONDS)){
                    System.out.println(Thread.currentThread().getName()+ "获得锁 占用了十秒");
                    TimeUnit.SECONDS.sleep(10);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
                System.out.println(Thread.currentThread().getName()+"正常结束!");
            }
        }
    }
}

运行结果：
在这里插入图片描述

5.2 tryLock()避免死锁

我们可以使用该方法配合失败重试机制来更好的解决死锁问题。

public class ReentrantLockTest {
    static Lock lock1 = new ReentrantLock();
    static Lock lock2 = new ReentrantLock();
    public static void main(String[] args) {
        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+tryLock）替换 firstLock.lock()
                while(!firstLock.tryLock()){
                    TimeUnit.MILLISECONDS.sleep(10);
                }

                TimeUnit.MILLISECONDS.sleep(10);//更好的形成死锁

                // 使用自旋锁（while+tryLock）替换 secondLock.lock()
                while(!secondLock.tryLock()){
                    TimeUnit.MILLISECONDS.sleep(10);//两个线程都因为获取不到锁进入这里，此时线程1持着lock1，线程2持着lock2
                    firstLock.unlock();//睡眠时间一过，线程1释放lock1，线程2释放lock2
                }
                //结束循环后，线程1获得锁lock2，线程2获得lock1

                System.out.println(Thread.currentThread().getName()+"正常结束!");

            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                secondLock.unlock();//线程1释放锁lock2，线程2释放lock1
            }
        }
    }
}

在这里插入图片描述
上述代码，我们可以看到直接使用lock()的话会造成死锁，但我们使用tryLock()替换一下写法，就能成功避免死锁。

解读：
1、首先都能知道两个线程都能通过第一个while循环，线程1获得lock1，线程2获得lock2
2、执行到第二个while循环时，由于都获取不到锁，加上睡眠10ms时间，确保两个线程都会进入该while内部
3、在第二个while内执行了unLock后，线程1释放lock1，线程2释放lock2，向下执行
4、两个线程再次执行tryLock()后，线程1获得锁lock2，线程2获得lock1
5、执行到finally的unlock()后，线程1释放锁lock2，线程2释放lock1

总之，tryLock避免死锁的关键是:

一是使用while+tryLock实现自旋代替lock
二是每次tryLock后都需要休眠一下才行，尤其是第二个while,必须确保两个线程都进入了while内部
三是在第二个while中释放上一个锁

由此，我们也可以改下部分代码的写法也可以同样避免死锁：

                //使用自旋锁（while+tryLock）替换 firstLock.lock()
                while(!firstLock.tryLock(10L,TimeUnit.MILLISECONDS)){
//                    TimeUnit.MILLISECONDS.sleep(10);
                }

                TimeUnit.MILLISECONDS.sleep(10);//更好的形成死锁

                // 使用自旋锁（while+tryLock）替换 secondLock.lock()
                while(!secondLock.tryLock(10L,TimeUnit.MILLISECONDS)){
//                    TimeUnit.MILLISECONDS.sleep(10);//两个线程都因为获取不到锁进入这里，此时线程1持着lock1，线程2持着lock2
                    firstLock.unlock();//睡眠时间一过，线程1释放lock1，线程2释放lock2
                }

从上述看，tryLock确实可以避免死锁，但是博主本人在工作中也没有遇到相关的使用场景，有使用过相关场景的人，欢迎评论分享一下，谢谢哈~

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

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

6.1 Condition使用简介

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

static Condition notEmpty = lock.newCondition();

static Condition notFull = lock.newCondition();

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

简单示例：

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();
    
        try {
         	System.out.println("主线程阻塞，等待通知");
            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();
            }
        }
    }
}

在这里插入图片描述

6.2 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条件方便的实现等待通知机制。

沉泽·

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
3
评论
JUC-线程锁之ReentrantLock详解（三）

一、ReentrantLock简介jdk中独占锁的实现除了使用关键字synchronized外,还可以使用ReentrantLock。虽然在性能上ReentrantLock和synchronized没有什么区别，但ReentrantLock相比synchronized而言功能更加丰富，它更灵活、更强大，增加了轮询、超时、中断等高级功能，更适合复杂的并发场景。二、 ReentrantLock是独占锁且可重入的例子：public class ReentrantLockTest { public
复制链接

扫一扫