【多线程】可重入锁 ReentrantLock

2022-04-02 00:36:22 阅读：175 来源： 互联网

标签：重入 Thread ReentrantLock 获取线程 test new 多线程

java除了使用关键字synchronized外，还可以使用ReentrantLock实现独占锁的功能。而且ReentrantLock相比synchronized而言功能更加丰富，使用起来更为灵活，也更适合复杂的并发场景。

一、简介

ReentrantLock常常对比着synchronized来分析，我们先对比着来看然后再一点一点分析。

synchronized是独占锁，加锁和解锁的过程自动进行，易于操作，但不够灵活。ReentrantLock也是独占锁，加锁和解锁的过程需要手动进行，不易操作，但非常灵活。
synchronized可重入，因为加锁和解锁自动进行，不必担心最后是否释放锁；ReentrantLock也可重入，但加锁和解锁需要手动进行，且次数需一样，否则其他线程无法获得锁。
synchronized不可响应中断，一个线程获取不到锁就一直等着；ReentrantLock可以响应中断。

ReentrantLock好像比synchronized关键字没好太多，我们再去看看synchronized所没有的，一个最主要的就是ReentrantLock还可以实现公平锁机制。什么叫公平锁呢？也就是在锁上等待时间最长的线程将获得锁的使用权。通俗的理解就是谁排队时间最长谁先执行获取锁。

二、使用

1、简单使用

代码：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @description 可重入锁测试
 * @author hzx
 * @date 2022-04-01
 */
public class ReentrantLockTest {
    private static final Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        new Thread(() -> test(),"线程A").start();
        new Thread(() -> test(),"线程B").start();
    }

    public static void test() {
        try {
            lock.lock();
            System.out.println(Thread.currentThread().getName()+"获取了锁");
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName()+"释放了锁");
            lock.unlock();
        }
    }
}

执行结果：

线程A获取了锁
线程A释放了锁
线程B获取了锁
线程B释放了锁

在这里我们定义了一个ReentrantLock，然后再test方法中分别lock和unlock，运行一边就可以实现我们的功能。这就是最简单的功能实现，代码很简单。我们再看看ReentrantLock和synchronized不一样的地方，那就是公平锁的实现。

2、公平锁实现

首先new一个ReentrantLock的时候参数为true，表明实现公平锁机制。公平锁的含义就是谁等的时间最长，谁就先获取锁。在这里我们多定义几个线程，然后在test方法中循环执行了两次加锁和解锁的过程。

代码：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @description 可重入锁测试（公平锁实现）
 * @author hzx
 * @date 2022-04-01
 */
public class ReentrantLockTest2 {
    private static final Lock lock = new ReentrantLock(true);

    public static void main(String[] args) {
        new Thread(() -> test(),"线程1").start();
        new Thread(() -> test(),"线程2").start();
        new Thread(() -> test(),"线程3").start();
        new Thread(() -> test(),"线程4").start();
        new Thread(() -> test(),"线程5").start();
    }

    public static void test() {
        for (int i = 0; i < 2; i++) {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"获取了锁");
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

执行结果：

线程1获取了锁
线程2获取了锁
线程3获取了锁
线程4获取了锁
线程5获取了锁
线程1获取了锁
线程2获取了锁
线程3获取了锁
线程4获取了锁
线程5获取了锁

3、非公平锁实现

非公平锁那就随机的获取，谁运气好，cpu时间片轮到哪个线程，哪个线程就能获取锁，和上面公平锁的区别很简单，就在于先new一个ReentrantLock的时候参数为false，当然我们也可以不写，默认就是false。

代码：

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @description 可重入锁测试（非公平锁实现）
 * @author hzx
 * @date 2022-04-01
 */
public class ReentrantLockTest3 {
    private static final Lock lock = new ReentrantLock(false);

    public static void main(String[] args) {
        new Thread(() -> test(),"线程1").start();
        new Thread(() -> test(),"线程2").start();
        new Thread(() -> test(),"线程3").start();
        new Thread(() -> test(),"线程4").start();
        new Thread(() -> test(),"线程5").start();
    }

    public static void test() {
        for (int i = 0; i < 2; i++) {
            try {
                lock.lock();
                System.out.println(Thread.currentThread().getName()+"获取了锁");
                TimeUnit.MILLISECONDS.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}

执行结果：

线程1获取了锁
线程2获取了锁
线程2获取了锁
线程3获取了锁
线程1获取了锁
线程3获取了锁
线程4获取了锁
线程4获取了锁
线程5获取了锁
线程5获取了锁

整个过程是随机的，没有固定的先后顺序，亲自测试时可以将for循环的次数增大，可以明显看出效果。

标签：重入,Thread,ReentrantLock,获取,线程,test,new,多线程
来源： https://www.cnblogs.com/hzxll/p/16089852.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

【多线程】可重入锁 ReentrantLock

一、简介

二、使用

1、简单使用

2、公平锁实现

3、非公平锁实现