java重入锁

最新推荐文章于 2024-07-31 19:38:21 发布
最新推荐文章于 2024-07-31 19:38:21 发布
阅读量763 收藏 5
点赞数 1
文章标签： java 并发编程 锁 synchronized
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lewis_9527/article/details/120847757
版权

一、重入锁理解

  • 某线程获取锁后，可以再次获取锁
  • synchronized 和 ReentrantLock 都是可重入锁
  • 可重入锁解决同一线程中内外层方法调用死锁的问题

二、可重入锁示例

1、synchronized 可重入锁演示

    /**
     * synchronized 重入锁示例
     */
    private static void reLockSyncDemo(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (this){
                    System.out.println("第1次获取锁，当前锁是：" + this);
                    int index=0;
                    while(true){
                        synchronized (this){
                            System.out.println("第" + (++index) + "次获取重入锁，当前锁是：" + this);
                        }
                        if (index == 5) {
                            break;
                        }
                    }
                }
            }
        }).start();
    }

在这里插入图片描述

2、ReentronLock 可重入锁演示

 		/**
     * ReentrantLock 重入锁示例
     */
    private static void reentrantLockDemo(){
        ReentrantLock rl = new ReentrantLock();
        new Thread(new Runnable() {
            @Override
            public void run() {
                rl.lock();
                try {
                    System.out.println("第1次获取锁，当前锁是：" + rl);
                    int index = 0;
                    while (true) {
                        rl.lock();
                        try {
                            System.out.println("第" + (++index) + "次获取重入锁，当前锁是：" + rl);
                            if (index == 5) {
                                break;
                            }
                        } finally {
                            rl.unlock();
                        }
                    }
                }finally{
                    rl.unlock();
                }
            }
        }).start();
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qqktbb4p-1634629290160)(/Users/lewis/Library/Application Support/typora-user-images/image-20211018153908473.png)]

ReentronLock 在多层可重入锁调用时，lock数必须与unlock数对等，否则会出现死锁

三、可重入锁简单实现

/**
 * MyRelock
 * Description 自定义实现重入锁简单实现，只完成了 lock和unlock
 * Create by wangzx
 * Date 2021年10月18日 15:43:00
 */
public class MyRelock implements Lock {

    //是否已经上锁
    private boolean isLocked = false;

    //记录当前线程
    Thread currThread = null;

    //记录当前锁数量
    private int lockNum = 0;

    @Override
    public void lock() {
        //获取当前线程
        Thread thread = Thread.currentThread();
        //当前已上锁 且 当前线程不是已上锁线程 进入循环等待
        while (isLocked && thread!= currThread ){
            try {
                Thread.sleep(50);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }

        // 锁状态置为true
        isLocked = true;
        // 记录当前线程
        currThread = thread;
        // 锁记录数 加一
        lockNum++;
    }


    @Override
    public void unlock() {
        // 判断是否为当前锁的线程
        if(Thread.currentThread()==currThread){
            // 锁记录 --
            lockNum--;
            if (lockNum == 0){
                isLocked = false;
            }
        }
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }
    @Override
    public boolean tryLock() {
        return false;
    }
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }
    @Override
    public Condition newCondition() {
        return null;
    }

测试

MyRelock myRelock = new MyRelock();
    private static void testMyRelock(){
        Demo demo = new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.functionA();
            }
        }).start();
    }

    private void functionA(){
        myRelock.lock();
        System.out.println("functionA 执行了,锁为："+myRelock);
        functionB();
        myRelock.unlock();
    }

    private void functionB(){
        myRelock.lock();
        System.out.println("functionB 执行了,锁为："+myRelock);
        myRelock.unlock();
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-clZjih1v-1634629290161)(/Users/lewis/Library/Application Support/typora-user-images/image-20211018163405154.png)]

四、synchronized可重入实现原理

每一个锁关联一个线程持有者和一个计数器，当计数器为0时表示当前锁没有被任何线程持有，此时任何线程都可以获取锁并执行相应的代码；当某一个线程获取锁成功后，jvm就会记录当前次有锁的线程，并将计数器加1；此时其他线程请求当前锁，则需要等待，如果持有当前锁的线程再次请求当前锁，可以获得当前锁，并且计数器加1，当锁内容执行完成后，计数器减1，如果当前计数器为0时，则线程持有者置为null，此时释放锁，唤醒等待线程。

五 、ReentronLock 可重入实现

// 同步队列，是一个带头结点的双向链表，用于实现锁的语义
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
  // 重入锁计数/许可证数量，在不同的锁中，使用方式有所不同
    private volatile int state;
  
 //CAS方式更新状态
  protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }
}


public class ReentrantLock implements Lock, java.io.Serializable {
  /*
     * 同步队列的实现者，实现了锁的语义
     *
     * 许可证数量==0：当前锁空闲
     * 许可证数量>0，当前锁被某一线程持有
     * 一个线程多次进入锁时，许可证数量会递增
     * 当线程释放锁时，许可证数量减少，直到为0
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();

        /**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        // 申请一次非公平锁，返回值代表锁是否申请成功
        final boolean nonfairTryAcquire(int acquires) {
            // 获取生成锁的线程
            final Thread current = Thread.currentThread();
            // 当前许可证数量  当前锁状态
            int c = getState();
            // 如果锁没有被任何线程占用
            if (c == 0) {
                /* 发现锁空闲时，不管【同步队列】中有没有人抢锁，该线程直接尝试抢锁，这也是"非公平"所在 */

                // 尝试更新许可证数量为acquires，返回true代表更新成功，即成功抢到了锁
                if (compareAndSetState(0, acquires)) {
                    // 设置当前线程为<占有者线程>
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            /* 至此，说明锁已被占用 */
            // 如果当前线程不是锁的占用者，直接返回false，代表抢锁失败，该线程需要去排队
            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;
        }
        // 释放一次锁，返回值表示同步锁是否处于自由状态（无线程持有）
        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;
        }
    }
}

上面是ReentronLock实现的部分代码## 一、重入锁理解

  • 某线程获取锁后，可以再次获取锁
  • synchronized 和 ReentrantLock 都是可重入锁
  • 可重入锁解决同一线程中内外层方法调用死锁的问题

二、可重入锁示例

1、synchronized 可重入锁演示

    /**
     * synchronized 重入锁示例
     */
    private static void reLockSyncDemo(){
        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (this){
                    System.out.println("第1次获取锁，当前锁是：" + this);
                    int index=0;
                    while(true){
                        synchronized (this){
                            System.out.println("第" + (++index) + "次获取重入锁，当前锁是：" + this);
                        }
                        if (index == 5) {
                            break;
                        }
                    }
                }
            }
        }).start();
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mceqrTCf-1634629291378)(/Users/lewis/Library/Application Support/typora-user-images/image-20211018153755361.png)]

2、ReentronLock 可重入锁演示

 		/**
     * ReentrantLock 重入锁示例
     */
    private static void reentrantLockDemo(){
        ReentrantLock rl = new ReentrantLock();
        new Thread(new Runnable() {
            @Override
            public void run() {
                rl.lock();
                try {
                    System.out.println("第1次获取锁，当前锁是：" + rl);
                    int index = 0;
                    while (true) {
                        rl.lock();
                        try {
                            System.out.println("第" + (++index) + "次获取重入锁，当前锁是：" + rl);
                            if (index == 5) {
                                break;
                            }
                        } finally {
                            rl.unlock();
                        }
                    }
                }finally{
                    rl.unlock();
                }
            }
        }).start();
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NeCrmrZm-1634629291379)(/Users/lewis/Library/Application Support/typora-user-images/image-20211018153908473.png)]

ReentronLock 在多层可重入锁调用时，lock数必须与unlock数对等，否则会出现死锁

三、可重入锁简单实现

/**
 * MyRelock
 * Description 自定义实现重入锁简单实现，只完成了 lock和unlock
 * Create by wangzx
 * Date 2021年10月18日 15:43:00
 */
public class MyRelock implements Lock {

    //是否已经上锁
    private boolean isLocked = false;

    //记录当前线程
    Thread currThread = null;

    //记录当前锁数量
    private int lockNum = 0;

    @Override
    public void lock() {
        //获取当前线程
        Thread thread = Thread.currentThread();
        //当前已上锁 且 当前线程不是已上锁线程 进入循环等待
        while (isLocked && thread!= currThread ){
            try {
                Thread.sleep(50);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }

        // 锁状态置为true
        isLocked = true;
        // 记录当前线程
        currThread = thread;
        // 锁记录数 加一
        lockNum++;
    }


    @Override
    public void unlock() {
        // 判断是否为当前锁的线程
        if(Thread.currentThread()==currThread){
            // 锁记录 --
            lockNum--;
            if (lockNum == 0){
                isLocked = false;
            }
        }
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {

    }
    @Override
    public boolean tryLock() {
        return false;
    }
    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        return false;
    }
    @Override
    public Condition newCondition() {
        return null;
    }

测试

MyRelock myRelock = new MyRelock();
    private static void testMyRelock(){
        Demo demo = new Demo();
        new Thread(new Runnable() {
            @Override
            public void run() {
                demo.functionA();
            }
        }).start();
    }

    private void functionA(){
        myRelock.lock();
        System.out.println("functionA 执行了,锁为："+myRelock);
        functionB();
        myRelock.unlock();
    }

    private void functionB(){
        myRelock.lock();
        System.out.println("functionB 执行了,锁为："+myRelock);
        myRelock.unlock();
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-24wCcr7q-1634629291380)(/Users/lewis/Library/Application Support/typora-user-images/image-20211018163405154.png)]

四、synchronized可重入实现原理

每一个锁关联一个线程持有者和一个计数器，当计数器为0时表示当前锁没有被任何线程持有，此时任何线程都可以获取锁并执行相应的代码；当某一个线程获取锁成功后，jvm就会记录当前次有锁的线程，并将计数器加1；此时其他线程请求当前锁，则需要等待，如果持有当前锁的线程再次请求当前锁，可以获得当前锁，并且计数器加1，当锁内容执行完成后，计数器减1，如果当前计数器为0时，则线程持有者置为null，此时释放锁，唤醒等待线程。

五 、ReentronLock 可重入实现

// 同步队列，是一个带头结点的双向链表，用于实现锁的语义
public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
  // 重入锁计数/许可证数量，在不同的锁中，使用方式有所不同
    private volatile int state;
  
 //CAS方式更新状态
  protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }
}


public class ReentrantLock implements Lock, java.io.Serializable {
  /*
     * 同步队列的实现者，实现了锁的语义
     *
     * 许可证数量==0：当前锁空闲
     * 许可证数量>0，当前锁被某一线程持有
     * 一个线程多次进入锁时，许可证数量会递增
     * 当线程释放锁时，许可证数量减少，直到为0
     */
    abstract static class Sync extends AbstractQueuedSynchronizer {
        private static final long serialVersionUID = -5179523762034025860L;

        /**
         * Performs {@link Lock#lock}. The main reason for subclassing
         * is to allow fast path for nonfair version.
         */
        abstract void lock();

        /**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        // 申请一次非公平锁，返回值代表锁是否申请成功
        final boolean nonfairTryAcquire(int acquires) {
            // 获取生成锁的线程
            final Thread current = Thread.currentThread();
            // 当前许可证数量  当前锁状态
            int c = getState();
            // 如果锁没有被任何线程占用
            if (c == 0) {
                /* 发现锁空闲时，不管【同步队列】中有没有人抢锁，该线程直接尝试抢锁，这也是"非公平"所在 */

                // 尝试更新许可证数量为acquires，返回true代表更新成功，即成功抢到了锁
                if (compareAndSetState(0, acquires)) {
                    // 设置当前线程为<占有者线程>
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            /* 至此，说明锁已被占用 */
            // 如果当前线程不是锁的占用者，直接返回false，代表抢锁失败，该线程需要去排队
            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;
        }
        // 释放一次锁，返回值表示同步锁是否处于自由状态（无线程持有）
        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;
        }
    }
}

上面是ReentronLock实现的部分代码

lewis_9527
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java重入锁ReentrantLock
12-22
摘要 　从使用场景的角度出发来介绍对ReentrantLock的使用，相对来说容易理解一些。 　场景1：如果发现该操作已经在执行中则不再执行（有状态执行） 　a、用在定时任务时，如果任务执行时间可能超过下次计划执行...
Java锁之可重入锁介绍
09-04
在Java中，可重入锁的主要实现有两种：`synchronized` 关键字和 `java.util.concurrent.locks.ReentrantLock` 类。这两种锁都具有可重入性，这也是它们能够在多线程编程中防止死锁的关键特性。 ### 一、可重入锁的...
关于Java 重入锁的理解
jiangbr的博客
02-19 4807
通过查看 Lock 的源码可知，Lock是一个接口。Lock有一个实现类 ReentrantLock （又名可重入锁），这种锁是可以反复多次进入的，其局限性在于同一个线程内 1public interface Lock { 2    void lock();//获得锁，如果锁已经被占用，则等待 3 4    void lockInterruptibly() throws InterruptedEx...
java锁--可重入锁
比利的博客
10-14 652
java锁--可重入锁
详解Java可重入锁ReentrantLock
常备不懈
12-28 1177
Java的`ReentrantLock`是一个高级的线程同步工具，提供了比传统的`synchronized`方法和语句更灵活、更丰富的线程同步机制。这个锁属于可重入锁（也称为递归锁），意味着同一个线程可以多次获取同一个锁而不会产生死锁。下面详细解释和说明`ReentrantLock`的特性和用法
java线程之可重入锁
一起coding，一起嗨。
05-08 6284
一、什么是可重入锁 可重入锁就是可以重复进入的锁，也叫递归锁。前提是同一把锁，如同一个类、同一个实例。 来自知乎的解释：可重入锁指的是同一个线程外层函数获得锁之后，内层递归函数仍然能获取该锁的代码，在同一个线程在外层方法获取锁的时候，在进入内层方法会自动获取锁。也就是说，线程可以进入任何一个他已经拥有锁的所有同步代码块。 Coffey强的解释:可重入锁，指的是以线程为单位，当一个线程获取对象锁之后，这个线程可以再次获取本对象上的锁，而其他的线程是不可以的。 synchronized 和 Reentra
Java ReentrantLock可重入锁的源码深度解析
终生学习践行者
07-05 3180
Java的ReentrantLock的源码实现，包括加锁、解锁的源码，以及公平性、重入性的实现！
聊聊java的两种锁同步锁和重入锁
查拉图斯特拉talk的博客
12-06 1354
总体来说，重入锁相对于同步锁提供了更多的灵活性和控制能力，但使用起来也更加复杂。在大部分情况下，使用同步锁已经足够满足线程同步的需求。只有在需要更高级的功能或更细粒度控制时，才需要考虑使用重入锁。
Java并发——锁（重入锁）
qq_56005481的博客
11-24 702
这样，当某个线程在等待获取锁的过程中被中断时，可以及时退出等待状态，避免线程长时间等待锁而无法响应中断。重入锁采用基于CAS操作的方式来实现锁的获取和释放，相对于synchronized关键字的互斥方式，重入锁的性能更高。总而言之，重入锁是一种功能强大且灵活的锁机制，它提供了可重入性、公平性、可中断等待和条件变量等特性，可以更好地满足不同并发场景的需求，并提供更好的性能和可靠性。3. 可中断等待：重入锁支持可中断的等待方式，可以更好地处理线程的中断请求，避免线程长时间等待锁而无法响应中断。
Java 重入锁 ReentrantLock使用实战
程序员小强的博客
04-06 7112
1.简述 ReentrantLock 是一个可重入的互斥（/独占）锁，又称为“独占锁”。 其可以完全替代 synchronized 关键字。JDK 1.5.0 引入的，其性能远好于 synchronized，但 JDK 1.6.0 开始，JDK 对 synchronized 做了大量的优化，使得两者差距并不大。但其提供了超出synchonized的其他高级功能(例如，中断锁等候、条件变量等)，并且...
Java 可重入锁 & 不可重入锁
xiangxiongfly
02-19 4284
文章目录Java 可重入锁 & 不可重入锁概述论证synchronized是可重入锁：论证Lock是可重入锁：自定义不可重入锁： Java 可重入锁 & 不可重入锁 概述 可重入锁：指可以重复使用的同步锁。如：synchronized、Lock、ReentrantReadWriteLock.ReadLock、ReentrantReadWriteLock.WriteLock。 不可重入锁：指不可以重复使用的同步锁。需要自定义锁。 论证synchronized是可重入锁： public cl
【JAVA程序员面试必备】详解 ReentrantLock：深入剖析 AQS 支撑下的可重入锁机制与实现原理
赵士杰——成功并非一蹴而就，而是在持之以恒的努力中逐渐实现。
02-20 2468
【JAVA程序员面试必备】详解 ReentrantLock：深入剖析 AQS 支撑下的可重入锁机制与实现原理
简单了解Java中的可重入锁
08-25
在Java编程语言中，可重入锁是一种特殊类型的锁，允许同一个线程多次获取同一锁。这种机制在处理递归调用或者嵌套同步块时非常有用，因为它防止了死锁的发生。本文将深入探讨Java中的可重入锁，包括其原理、使用以及...
详解java并发之重入锁-ReentrantLock
08-26
详解 Java 并发之重入锁-ReentrantLock Java 中的并发编程是一种复杂的技术，需要深入了解 Java 的并发机制和锁机制。ReentrantLock 是 Java 中的一种常用锁机制，它提供了一个可重入的锁机制，能够确保线程安全。...
Java可重入锁的实现原理与应用场景
08-26
Java可重入锁的实现原理与应用场景 Java可重入锁是一种特殊的锁机制，允许同一个线程在不同的层次上获取同一个锁，而不会发生死锁或阻塞的情况。这种锁机制广泛应用于多线程编程中，用于解决线程之间的同步问题。 ...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 508
1.导入hutool的maven依赖。2.复制一下代码执行。
社区养老服务小程序的设计
最新发布
Karen198的博客
07-31 297
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 288
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Java并发（十一）一文搞懂Java并发各种容器
m0_58466443的博客
07-29 797
同步容器将所有对容器状态的访问都串行化，以保证线程安全性，这种策略会严重降低并发性。Java 1.5 后提供了多种并发容器，使用并发容器来替代同步容器，可以极大地提高伸缩性并降低风险。并发容器对应的普通容器描述HashMapJava 1.8 之前采用分段锁机制细化锁粒度，降低阻塞，从而提高并发性；Java 1.8 之后基于 CAS 实现。SortedMap基于跳表实现的ArrayListSet基于实现。SortedSet基于实现。Queue线程安全的无界队列。底层采用单链表。支持 FIFO。
java重入锁和公平锁
05-27
Java中的重入锁（ReentrantLock）和公平锁（FairLock）都是多线程编程中常用的锁类型。 重入锁是指同一个线程在获取锁之后，可以重复获取该锁而不会造成死锁，也就是说，重入锁支持可重入性。在Java中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值