ReentrantLock

最新推荐文章于 2024-10-16 10:13:45 发布

cherishfh

最新推荐文章于 2024-10-16 10:13:45 发布

阅读量163

点赞数 1

分类专栏： java 文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/handapeng1/article/details/127828968

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

AQS原理分析

java.util.concurrent包中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这些行为的抽象就是基于 AbstractQueuedSynchronizer（简称AQS）实现的，AQS是一个抽象同步框架，可以用来实现一个依赖状态的同步器。

一般是通过一个内部类Sync继承 AQS
将同步器所有调用都映射到Sync对应的方法

特性

阻塞等待队列
共享/独占
公平/非公平
可重入
允许中断

state

AQS内部维护属性volatile int state
state表示资源的可用状态
State可以通过getState()、setState()、compareAndSetState()进行操作

AQS定义两种资源共享方式

Exclusive-独占，只有一个线程能执行，如ReentrantLock

Share-共享，多个线程可以同时执行，如Semaphore/CountDownLatch

AQS定义两种队列

同步等待队列：用于维护获取锁失败时入队的线程

条件等待队列：调用await()方法回释放锁，然后线程会加入条件等待队列队尾，调用singal()唤醒的时候会把条件队列的线程节点移动到同步队列队尾，然后等待unlock解锁unpark同步等待队列的线程

AQS 定义了5个队列中节点状态：

值为0，初始状态，表示当前节点在同步等待队列中，等待获取锁
CANCELLED，值为1，表示当前线程被取消
SIGNAL，值为-1，表示当前节点的后继节点包含的线程需要运行，也就是unpark
CONDITION，值为-2，表示当前节点在等待condition，也就是在condition队列中
PROPAGATE，值为-3，表示当前场景下后续的acquireShared能够得以执行

自定义同步器实现时主要实现以下几种方法：

不同的自定义同步器竞争共享资源的方式也不同。
自定义同步器在实现时只需要实现共享资源state的获取与释放方式即可，
至于具体线程等待队列的维护（如获取资源失败入队/唤醒出队等），AQS已经在顶层实现好了。

isHeldExclusively()：该线程是否正在独占资源。只有用到condition才需要去实现它。

tryAcquire(int)：独占方式。尝试获取资源，成功则返回true，失败则返回false

tryRelease(int)：独占方式。尝试释放资源，成功则返回true，失败则返回false。

tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。

tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false。

同步等待队列

基于双向链表数据结构的队列，是FIFO先进先出线程等待队列

AQS 依赖同步队列来完成同步状态的管理：

当前线程如果获取同步状态失败时，AQS则会将当前线程已经等待状态等信息构造成一个节点（Node）并将其加入到CLH同步队列，同时会阻塞当前线程
当同步状态释放时，会把首节点唤醒（公平锁），使其再次尝试获取同步状态。
通过signal或signalAll将条件队列中的节点转移到同步队列。（由条件队列转化为同步队列）

条件等待队列

AQS中条件队列是使用单向链表保存的，用nextWaiter来连接:

调用await方法阻塞线程；
当前线程存在于同步队列的头结点，调用await方法进行阻塞（从同步队列转化到条件队列）当前线程获取锁就相当于同步队列的头节点head，调用await把当前节点转移到条件队列的尾结点，就相当于同步转条件

Condition接口

调用Condition#await方法

会释放当前持有的锁，然后阻塞当前线程，同时向Condition队列尾部添加一个节点，所以调用Condition#await方法的时候必须持有锁。

调用Condition#signal方法

会将Condition队列（条件等待队列）的首节点移动到阻塞队列（同步等待队列）尾部，
(唤醒之后这个线程就可以去竞争锁了)，所以调用Condition#signal方法的时候必须持有锁，持有锁的线程唤醒被因调用Condition#await方法而阻塞的线程。
然后唤醒因调用Condition#await方法而阻塞的线程

ReentrantLock详解

ReentrantLock是一种基于AQS框架的应用实现，是JDK中的一种线程并发访问的同步手段，它的功能类似于synchronized 是一种互斥锁，可以保证线程安全。

可中断
可以设置超时时间
可以设置为公平锁
支持多个条件变量
与 synchronized 一样，都支持可重入

synchronized和ReentrantLock的区别

synchronized是JVM层次的锁实现，ReentrantLock是JDK层次的锁实现；
synchronized的锁状态是无法在代码中直接判断的，但是ReentrantLock可以通过ReentrantLock#isLocked判断；
synchronized是非公平锁，ReentrantLock是可以是公平也可以是非公平的；
synchronized是不可以被中断的，而ReentrantLock#lockInterruptibly方法是可以被中断的(中断等待获取锁的线程)；
在发生异常时synchronized会自动释放锁，而ReentrantLock需要开发者在finally块中显示释放锁；
ReentrantLock获取锁的形式有多种：如立即返回是否成功的tryLock(),以及等待指定时长的获取，更加灵活；
synchronized在特定的情况下对于已经在等待的线程是后来的线程先获得锁（回顾一下sychronized的唤醒策略，cxq队列先进后出，EntryList为空直接转移为EntryList队列获取锁），而ReentrantLock对于已经在等待的线程是先来的线程先获得锁；

ReentrantLock的使用

同步执行

ReentrantLock lock = new ReentrantLock(); //参数默认false，不公平锁  
ReentrantLock lock = new ReentrantLock(true); //公平锁  
//加锁    
lock.lock();
 try {
      //临界区 
}
 finally {
     // 解锁
     lock.unlock()
}

可重入

public static void method1() {
        lock.lock();
        try {
            log.debug("execute method1");
            method2();
        } finally {
            lock.unlock();
        }
    }
    public static void method2() {
        lock.lock();
        try {
            log.debug("execute method2");
            method3();
        } finally {
            lock.unlock();
        }
    }

可中断

lockInterruptibly(要么获取锁，要么直接进入同步等待队列，如果被中断会抛异常)

public static void main(String[] args) throws InterruptedException {
        ReentrantLock lock = new ReentrantLock();
        Thread t1 = new Thread(() -> {
            log.debug("t1启动。。。");
            try {
                lock.lockInterruptibly();
                try {
                    log.debug("t1获得了锁");
                } finally {
                    lock.unlock();
                }
            } catch (
                    InterruptedException e) {
                e.printStackTrace();
                log.debug("t1等锁的过程被中断");
            }
        }, "t1");
        lock.lock();
        try {
            log.debug("main线程获得了锁");
            t1.start();
            Thread.sleep(1000);
            t1.interrupt();
            log.debug("线程t1执行中断");
        }finally {
            lock.unlock();
        }
    }

锁超时

立即失败

 // 注意： 即使是设置的公平锁，此方法也会立即返回获取锁成功或失败，公平策略不生效
            if (!lock.tryLock()) {
                log.debug("t1获取锁失败，立即返回false");
                return;
            }

超时失败

if (!lock.tryLock(1, TimeUnit.SECONDS)) {
                    log.debug("等待 1s 后获取锁失败，返回");
                    return;
                }

条件变量

java.util.concurrent类库中提供Condition类来实现线程之间的协调。调用Condition.await() 方法使线程等待，其他线程调用Condition.signal() 或 Condition.signalAll() 方法唤醒等待的线程。
调用Condition的await()和signal()方法，都必须在lock保护之内。

ReentrantLock源码分析

| ProcessOn