java重入锁(ReentrantLock)学习

最新推荐文章于 2024-08-19 21:26:48 发布
最新推荐文章于 2024-08-19 21:26:48 发布
阅读量1.8k 收藏 3
点赞数 1
分类专栏： java并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Andanc/article/details/118914997
版权

重入锁

 重入锁ReentrantLock，顾名思义，就是支持重进入的锁，他表示该锁能够支持一个线程对资源的重复加锁。除此之外，该锁还支持获取锁时的公平和非公平选择。
  ReentrantLock虽然没能像synchronized关键字一样支持隐式的重进入，但是在调用lock()方法时，已经获取到锁的线程，能够再次调用lock()方法获取锁而不被阻塞。
  这里提到一个锁获取公平性问题，如果在绝对时间上，先对锁进行获取的请求一定会先被满足，那么这个锁是公平的，反之则是不公平的，公平的获取锁，也就是等待的时间最长的线程优先获取锁，也可以说锁获取是有顺序的。ReentantLock提供了一个构造函数，能够控制锁是否公平。
  事实上，公平的锁机制往往没有非公平的效率高，但是，并不是任何场景都是以TPS（查询率）作为唯一的指标，公平锁能够减少“饥饿”发生的概率，等待越久的请求越是能够得到优先满足。

  1. 实现重进入
      重进入是值任意线程在获取到锁之后能够再次获取该锁而不会被锁所阻塞，该特性的实现需要解决以下两个问题
    1）线程再次获取锁。锁需要去识别获取锁的线程是否为当前占据锁的线程，如果是，则再次成功获取
    2）锁的最终释放。线程重复n次获取了锁，随后在第n次释放该锁后，其他线程能够获取到该锁。锁的最终释放要求锁对于获取进行计数自增，计数表示当前锁被重复获取的次数，而锁被释放时，计数自减，当计数等于0时表示锁已经成功释放。

ReentrantLock获取同步状态的核心代码如下

     final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            //获取到当前的状态
            int c = getState();
            //等于0的时候获取锁
            if (c == 0) {
                if (compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                //如果大于最多的锁抛出异常
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

 该方法增加了再次获取同步状态的处理逻辑：通过判断当前线程是否为获取锁的线程来决定获取操作是否成功，如果是获取锁的线程再次请求，则将同步状态值进行增加并返回true，表示获取同步状态成功。
 成功获取锁的线程再次获取锁，只是增加了同步状态值，这也就要求ReentrantLock在释放同步状态时减少同步状态值，核心代码如下

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

如果说该锁被获取了n次，那么前(n-1)次tryRelease(int releases)方法必须返回false，而只有同步状态完全释放了，才能返回true。可以看到，该方法将同步状态是否为0作为最终释放的条件，当同步状态为0时，将占有线程设置为null，并返回true，表示释放成功。

2.公平锁与非公平锁的区别
 公平性是否是针对获取锁而言的，如果一个锁是公平的，那么锁的获取顺序就应该符合请求的绝对时间顺序，也就是FIFO。
 对于非公平锁来说，只要CAS设置同步状态成功，则表示当前线程获取了锁，而公平锁则不同

  protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                if (!hasQueuedPredecessors() &&
                    compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

 该方法与nonfairTryAcquire(int acquires)比较，唯一不同的位置为判断条件多了hasQueuedPredecessors()方法，即加入了同步队列中当前节点是否有前驱节点的判断，如果该方法返回true，则表示有线程比当前线程更早的请求获取锁，因此需要等待前驱线程获取并释放锁之后才能继续获取锁。
 测试观察公平与非公平锁的区别
  公平锁代码

package reentrantlock;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author liusupeng
 * @date 2021/7/19 22:45
 */
public class FaireAndUnfairTest {

    private static final Lock FAIR_LOCK = new ReentrantLock2(true);
    private static final Lock UNFAIR_LOCK = new ReentrantLock2(false);


    public static void main(String[] args) {

        fair();
    }

    /**
     * 公平锁
     */
    public static void fair() {
        testLock(FAIR_LOCK);

    }

    private static void testLock(Lock lock) {
        /**
         * 创建5个线程来执行
         */
        for (int i = 1; i <= 5; i++) {
            Job job = new Job(lock);
            job.start();
        }
    }

    private static class Job extends Thread {
        private final Lock lock;

        public Job(Lock lock) {
            this.lock = lock;
        }

        @Override
        public void run() {

            for (int i = 1; i <= 2; i++) {
                //先上锁
                lock.lock();
                try {
                    //获取等待队列
                    ArrayList<Thread> list = (ArrayList<Thread>) ((ReentrantLock2) lock).getQueuedThreads();

                    System.out.print("当前线程的名字：" + this.getName() + "其他线程的名字[");
                    list.forEach(e -> {
                        System.out.print(e.getName() + ",");
                    });
                    System.out.println("]");

                } finally {
                    //释放锁
                    lock.unlock();
                }

            }
        }
    }


}

class ReentrantLock2 extends ReentrantLock {

    public ReentrantLock2(boolean fair) {
        super(fair);
    }

    @Override
    public Collection<Thread> getQueuedThreads() {
        //获取父类的线程等待队列里的线程数据，并且转换下顺序
        List<Thread> arrayList = new ArrayList<Thread>(super.getQueuedThreads());
        Collections.reverse(arrayList);
        return arrayList;
    }


}

输出内容

当前线程的名字：Thread-0其他线程的名字[Thread-1,]
当前线程的名字：Thread-1其他线程的名字[Thread-2,Thread-3,Thread-4,Thread-0,]
当前线程的名字：Thread-2其他线程的名字[Thread-3,Thread-4,Thread-0,Thread-1,]
当前线程的名字：Thread-3其他线程的名字[Thread-4,Thread-0,Thread-1,Thread-2,]
当前线程的名字：Thread-4其他线程的名字[Thread-0,Thread-1,Thread-2,Thread-3,]
当前线程的名字：Thread-0其他线程的名字[Thread-1,Thread-2,Thread-3,Thread-4,]
当前线程的名字：Thread-1其他线程的名字[Thread-2,Thread-3,Thread-4,]
当前线程的名字：Thread-2其他线程的名字[Thread-3,Thread-4,]
当前线程的名字：Thread-3其他线程的名字[Thread-4,]
当前线程的名字：Thread-4其他线程的名字[]

Process finished with exit code 0

非公平锁

package reentrantlock;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author liusupeng
 * @date 2021/7/19 22:45
 */
public class FaireAndUnfairTest {

    private static final Lock FAIR_LOCK = new ReentrantLock2(true);
    private static final Lock UNFAIR_LOCK = new ReentrantLock2(false);


    public static void main(String[] args) {

        unFair();
    }

    /**
     * 非公平锁
     */
    public static void unFair() {
        testLock(UNFAIR_LOCK);

    }

    private static void testLock(Lock lock) {
        /**
         * 创建5个线程来执行
         */
        for (int i = 1; i <= 5; i++) {
            Job job = new Job(lock);
            job.start();
        }
    }

    private static class Job extends Thread {
        private final Lock lock;

        public Job(Lock lock) {
            this.lock = lock;
        }

        @Override
        public void run() {

            for (int i = 1; i <= 2; i++) {
                //先上锁
                lock.lock();
                try {
                    //获取等待队列
                    ArrayList<Thread> list = (ArrayList<Thread>) ((ReentrantLock2) lock).getQueuedThreads();

                    System.out.print("当前线程的名字：" + this.getName() + "其他线程的名字[");
                    list.forEach(e -> {
                        System.out.print(e.getName() + ",");
                    });
                    System.out.println("]");

                } finally {
                    //释放锁
                    lock.unlock();
                }

            }
        }
    }


}

class ReentrantLock2 extends ReentrantLock {

    public ReentrantLock2(boolean fair) {
        super(fair);
    }

    @Override
    public Collection<Thread> getQueuedThreads() {
          //获取父类的线程等待队列里的线程数据，并且转换下顺序
        List<Thread> arrayList = new ArrayList<Thread>(super.getQueuedThreads());
        Collections.reverse(arrayList);
        return arrayList;
    }


}

输出内容

当前线程的名字：Thread-0其他线程的名字[]
当前线程的名字：Thread-0其他线程的名字[Thread-1,Thread-2,Thread-3,Thread-4,]
当前线程的名字：Thread-1其他线程的名字[Thread-2,Thread-3,Thread-4,]
当前线程的名字：Thread-1其他线程的名字[Thread-2,Thread-3,Thread-4,]
当前线程的名字：Thread-2其他线程的名字[Thread-3,Thread-4,]
当前线程的名字：Thread-2其他线程的名字[Thread-3,Thread-4,]
当前线程的名字：Thread-3其他线程的名字[Thread-4,]
当前线程的名字：Thread-3其他线程的名字[Thread-4,]
当前线程的名字：Thread-4其他线程的名字[]
当前线程的名字：Thread-4其他线程的名字[]

 观察以上代码可以发现，公平性锁每次都是从同步状态队列中的第一个节点获取到锁，而非公平锁则出现了一个线程连续获取锁的情况
 为什么会出现线程连续获取锁的情况呢？
当一个线程请求锁的时候，只要获取了同步状态即成功获取锁，在这个前提下，刚释放的锁的线程再次获取同步状态的几率会非常的大，使得其他线程只能在同步队列中等待。
为什么默认是非公平锁
 在进行公平锁和非公平锁的测试时，总耗时是其94.3倍，总切换次数是其133倍。可以看出，公平锁是明显保证了锁的获取FIFO（数据缓冲器）原则，而代价就是进行大量的线程切换。非公平锁虽然可能造成线程饥饿，但是极少的线程切换，保证了其更大的QBS；

Andanc
关注
专栏目录
Java 并发编程：ReentrantLock 锁与 AQS
栗筝i的博客
08-10 1230
大家好，我是栗筝i，这篇文章是我的 “栗筝i 的 Java 技术栈” 专栏的第 030 篇文章，在 “栗筝i 的 Java 技术栈” 这个专栏中我会持续为大家更新 Java 技术相关全套技术栈内容。专栏的主要目标是已经有一定 Java 开发经验，并希望进一步完善自己对整个 Java 技术体系来充实自己的技术栈的同学。与此同时，本专栏的所有文章，也都会准备充足的代码示例和完善的知识点梳理，因此也十分适合零基础的小白和要准备工作面试的同学学习。
可重入锁ReentrantLock
weixin_41987908的博客
02-23 144
   java除了使用关键字synchronized外，还可以使用ReentrantLock实现独占锁的功能。而且ReentrantLock相比synchronized而言功能更加丰富，使用起来更为灵活，也更适合复杂的并发场景。这篇文章主要是从使用的角度来分析一下ReentrantLock （一）简介 ReentrantLock常常对比着synchronized来分析，我们先对比着来看然后再一点一点分析。
Java的ReentrantLock(可重入锁)详解上篇
lt_xiaodou的博客
08-24 3268
比如我们有两个线程A，B，第一个线程A已经获取到锁了，B在获取锁的时候肯定获取不到，则会把B包装成Node，然后加入到同步的等待队列中，此时队列中只有一个head头节点和线程B所在的Node节点，head头节点在初始化时，它的waitStatus等于0，在第一次循环时，把头节点的waitStatus更新为SIGNAL，也就是-1，第二次循环时，因为head节点额waitStatus等于-1，所以在第一个if时，直接返回了true，告诉我们可以把当前线程中断掉。
Java锁之重入锁
weixin_34309435的博客
12-20 114
在讲重入锁之前，我们先看一段代码上述代码想要实现的效果，就是使用两个线程对i分别进行累加一百万次，最终希望i的值是二百万，如果按照上述代码运行程序，你会发现i的值在绝大多数情况下都不能达到200万，原因就是多线程的数据同步问题。为了解决上述问题，我们自然而然想到synchronized关键字，通过对程序进行简单改造，如下图，红框中的部分就...
【并发编程】详解 ReentrantLock：深入剖析 AQS 支撑下的可重入锁机制与实现原理
最新发布
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
08-19 2577
【并发编程】详解 ReentrantLock：深入剖析 AQS 支撑下的可重入锁机制与实现原理
一文彻底理解ReentrantLock可重入锁的使用
weixin_41669668的博客
01-28 133
ava除了使用关键字synchronized外，还可以使用ReentrantLock实现独占锁的功能。而且ReentrantLock相比synchronized而言功能更加丰富，使用起来更为灵活，也更适合复杂的并发场景。这篇文章主要是从使用的角度来分析一下ReentrantLock。 一、简介 ReentrantLock常常对比着synchronized来分析，我们先对比着来看然后再一点一点分析。 （1）synchronized是独占锁，加锁和解锁的过程自动进行，易于操作，但不够灵活。ReentrantLo
Java ReentrantLock
weixin_35821291的博客
03-23 4955
1. 锁的意义——线程同步 2. 案例——基于ReentrantLock来实现同步 public class A { public static ReentrantLock reentrantLock = new ReentrantLock(); public static void main(String[] args) { new Thread(() -> { testSync(); }, "t1").start()
java重入锁
ShakespeareLies的博客
03-13 385
在Java的重入锁机制中，这个“万能钥匙”就好比是线程的锁计数器，当线程首次获取锁时，计数器加1，再次获取时继续加1。这样设计的好处在于，当一个线程在持有锁的情况下需要再次访问同一把锁保护的其他资源时，不会因为自己已经持有锁而被阻塞，从而避免了死锁的发生。重入锁允许同一个线程在获取锁后，可以再次获取该锁，而不会被自己持有的锁阻塞。公平锁：按照线程获取锁的先后顺序来分配锁，先请求锁的线程在锁释放时将优先获得锁。非公平锁：在锁释放时，任何等待锁的线程都有可能获得锁，不保证锁获取的绝对顺序。
教你完全理解ReentrantLock重入锁
10-16
ReentrantLock支持重入性，意味着一个线程可以多次进入同一段被该锁保护的代码，只要这个线程还没有释放这个锁。这种特性对于某些复杂并发场景特别有用。 在ReentrantLock中，重入性是通过维护每个锁的同步状态（即...
java多线程并发重入锁ReentrantLock源码详细分析
04-18 588
synchronized同步代码块 一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞 /** * @company： 拓薪教育 * @author： 大亮老师 QQ：206229531 */ public class Test1 { public static void main(String[] args) { ...
java lock signal方法_java多线程系列(四)---ReentrantLock的使用详解
weixin_36173545的博客
02-13 478
Lock的使用前言：本系列将从零开始讲解java多线程相关的技术，内容参考于《java多线程核心技术》与《java并发编程实战》等相关资料，希望站在巨人的肩膀上,再通过我的理解能让知识更加简单易懂。ReentrantLocak特性(对比synchronized)尝试获得锁获取到锁的线程能够响应中断ReentrantLock(重入锁)publicclassMyService{privateL...
java 重入锁_Java可重入锁详解
weixin_36337389的博客
02-12 790
作者： 一字马胡转载标志 【2017-11-03】更新日志日期更新内容备注2017-11-03添加转载标志持续更新前言在java中，锁是实现并发的关键组件，多个线程之间的同步关系需要锁来保证，所谓锁，其语义就是资源获取到资源释放的一系列过程，使用lock的意图就是想要进入临界区对共享资源执行操作，使用unlock说明线程已经完成了相关工作或者发生了异常从而离开临界区释放共享资源，可以说，在多线程环...
Java 可重入锁
浩子的博客
04-18 486
四、可重入锁： 本文里面讲的是广义上的可重入锁，而不是单指JAVA下的ReentrantLock。 可重入锁，也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。 在JAVA环境下 ReentrantLock 和synchronized 都是 可重入锁 下面是使用实例 01 public clas
java可重入锁
方亚军的博客
03-25 498
可重入锁指的是在一个线程中可以多次获取同一把锁 比如：一个线程在执行一个带锁的方法，该方法中又调用了另一个需要相同锁的方法，则该线程可以直接执行调用的方法，而无需重新获得锁； 在java中ReentrantLock和synchronized都是可重入锁 代码示例 /** * 可重入锁 */ public class Reentrant { Lock lock = new Reentra...
java 可重入锁
zzwpublic的专栏
02-15 199
一 什么是可重入锁？ 若一个程序或子程序可以“在任意时刻被中断然后操作系统调度执行另外一段代码，这段代码又调用了该子程序不会出错”，则称其为可重入（reentrant或re-entrant）的。即当该子程序正在运行时，执行线程可以再次进入并执行它，仍然获得符合设计时预期的结果。与多线程并发执行的线程安全不同，可重入强调对单个线程执行时重新进入同一个子程序仍然是安全的。 ...
Java锁之可重入锁
echola_mendes的博客
07-19 1244
ReentrantLock可以实现公平锁和非公平锁ReentrantLock默认实现的是非公平锁ReentrantLock的获取锁和释放锁必须成对出现，锁了几次，也要释放几次释放锁的操作必须放在finally中执行实例方法tryLock()会尝试获取锁，会立即返回，返回值表示是否获取成功实例方法tryLock(long timeout, TimeUnit unit)会在指定的时间内尝试获取锁，指定的时间内是否能够获取锁，都会返回，返回值表示是否获取锁成功，该方法会响应线程的中断。
JAVA锁:重入锁
qq_25292419的博客
05-11 149
1.重入锁 锁作为并发共享数据，保证一致性的工具，在JAVA平台有多种实现(如 synchronized（重量级） 和 ReentrantLock(轻量级)等等 ) 。 这些已经写好提供的锁为我们开发提供了便利。 重入锁，也叫做递归锁，指的是同一线程 外层函数获得锁之后 ，内层递归函数仍然有获取该锁的代码，但不受影响。 在JAVA环境下 ReentrantLock 和synchronized 都是 可重入锁 synchronized 测试可重入锁： public class Test implements
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值