AQS之独占锁ReentrantLock

最新推荐文章于 2024-04-27 15:51:34 发布

不爱学习的cyy

最新推荐文章于 2024-04-27 15:51:34 发布

阅读量211

点赞数

分类专栏： java 并发编程文章标签： java 开发语言

本文链接：https://blog.csdn.net/cyy15280752410/article/details/128170895

版权

java 并发编程专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、AQS

1、AQS简介

AbstractQueuedSynchronizer简称AQS，AQS是一个依赖状态(state)的同步器，是多线程访问其共享资源的同步框架

2、AQS特性

共享/独占

Exclusive-独占：只有一个线程可以执行，如ReentrantLock

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

公平/非公平
阻塞等待队列

同步等待队列：是个双向链表，当前线程获取同步状态失败，AQS会将当前线程构造成一个Node节点，然后进入到同步队列并阻塞当前线程；当同步状态释放时，公平锁中会把首节点唤醒，会使其再次尝试获取同步状态；非公平锁中当有其他线程进入会去尝试获取同步状态；通过signal或signalAll将条件队列中的节点转移到同步队列。（由条件队列转化为同步队列）

条件等待队列：是个单链表，用nextWaiter来连接，调用await()的时会阻塞并释放锁，然后该线程会加入到条件队列，调用signal()唤醒，会把条件队列中的线程节点移动到同步队列中，等待再次获得锁

可重入
允许中断

AQS内部通过state来表示该资源是否可用，state为0，表示当前资源没有被占用，state为1，表示当前资源已被占用。

AQS中节点状态

// 使用CAS更改状态，volatile保证线程可见性
volatile int waitStatus

CANCELLED = 1 ；在同步队列中等待的线程等待超时或者被中断，需要从同步队列中取消等待
值为0，初始化状态，表示当前节点在sync队列中，等待着获取锁
初始化状态，表示当前节点在sync队列中，等待着获取锁
SIGNAL = -1；后继节点的线程处于等待状态，而当前的节点如果释放了同步状态或者被取消，将会通知后继节点，使后继节点的线程得以运行
CONDITION = -2 ；节点在等待队列中，节点的线程等待在Condition上，当其他线程对Condition调用了signal()方法后，该节点会从等待队列中转移到同步队列中，加入到同步状态的获取中
PROPAGATE = -3 ；表示下一次共享式同步状态获取将会被无条件地传播下去

3、AQS实现方法

tryAcquire(int)：独占方式。尝试获取资源，成功返回true，失败返回false
tryRelease(int)：独占方式。尝试释放资源，成功返回true，失败返回false
tryAcquireShared(int)：共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源
tryReleaseShared(int)：共享方式。尝试释放资源，如果释放后允许唤醒后续等待结点返回true，否则返回false

二、ReentrantLock

1、ReentrantLock简介

ReentrantLock是基于AQS框架的应用实现的互斥锁，可以保证线程安全

2、ReentrantLock特性

可设置超时的锁
可重入
可中断
可实现公平、非公平锁

3、ReentrantLock的几种锁

ReentrantLock锁有几种：lock、tryLock、tryLock(long timeout, TimeUnit unit)、lockInterruptibly

lock 阻塞等待获取锁，优先考虑获取锁，待获取锁成功后，才响应中断
lockInterruptibly 优先考虑响应中断，而不是响应锁的普通获取或重入获取
tryLock() 是一个有返回值的方法，试图申请一个锁，在成功获得锁后返回true，否则，立即返回false,而且线程可以立即离开去做其他的事情
tryLock(long timeout, TimeUnit unit) 是一个具有超时参数的尝试申请锁的方法，阻塞时间不会超过给定的值；如果成功则返回true
lockInterruptibly()方法能够中断等待获取锁的线程。当两个线程同时通过lock.lockInterruptibly()获取某个锁时，假若此时线程A获取到了锁，而线程B只有等待，那么对线程B调用threadB.interrupt()方法能够中断线程B的等待过程。 ReentrantLock.lock方法不允许Thread.interrupt中断,即使检测到Thread.isInterrupted,一样会继续尝试获取锁，失败则继续休眠。只是在最后获取锁成功后再把当前线程置为interrupted状态,然后再中断线程

@Slf4j
public class ReentrantLockDemo3 {

    public static void main(String[] args) {
        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();
            //先让线程t1执行
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            t1.interrupt();
            log.debug("线程t1执行中断");
        } finally {
            lock.unlock();
        }
    }
}

4、synchronized和ReentrantLock的区别

synchronized是JVM内置锁，RenntrantLock是jdk层次的锁
synchronized只可以实现非公平锁，ReentrantLock可以实现公平锁、非公平锁
synchronized会自动释放锁，ReentrantLock需要收到释放锁
synchronized是不可以被中断的，而ReentrantLock#lockInterruptibly方法是可以被中断的
ReentrantLock获取锁的方式有多种：如lock、tryLock、tryLock(long timeout, TimeUnit unit)、lockInterruptibly。，更加灵活；

三、ReentrantLock源码图

AbstractQueuedSynchronizer

/**
     * 节点加入CLH同步队列
     */
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize
                //队列为空需要初始化，创建空的头节点
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else {
                node.prev = t;
                //set尾部节点
                if (compareAndSetTail(t, node)) {//当前节点置为尾部
                    t.next = node; //前驱节点的next指针指向当前节点
                    return t;
                }
            }
        }
    }
    private Node addWaiter(Node mode) {
        // 1. 将当前线程构建成Node类型
        Node node = new Node(Thread.currentThread(), mode);
        Node pred = tail;
        // 2. 1当前尾节点是否为null？
        if (pred != null) {
            // 2.2 将当前节点尾插入的方式
            node.prev = pred;
            // 2.3 CAS将节点插入同步队列的尾部
            if (compareAndSetTail(pred, node)) {
                pred.next = node;
                return node;
            }
        }
        enq(node);
        return node;
    }

	private void unparkSuccessor(Node node) {
        //获取wait状态
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);// 将等待状态waitStatus设置为初始值0

        /**
         * 若后继结点为空，或状态为CANCEL（已失效），则从后尾部往前遍历找到最前的一个处于正常阻塞状态的结点
         * 进行唤醒
         */
        Node s = node.next; //head.next = Node1 ,thread = T3
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);//唤醒线程,T3唤醒
    }

   /**
     * 已经在队列当中的Thread节点，准备阻塞等待获取锁
     */
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {//死循环
                final Node p = node.predecessor();//找到当前结点的前驱结点
                if (p == head && tryAcquire(arg)) {//如果前驱结点是头结点，才tryAcquire，其他结点是没有机会tryAcquire的。
                    setHead(node);//获取同步状态成功，将当前结点设置为头结点。
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                /**
                 * 如果前驱节点不是Head，通过shouldParkAfterFailedAcquire判断是否应该阻塞
                 * 前驱节点信号量为-1，当前线程可以安全被parkAndCheckInterrupt用来阻塞线程
                 */
                if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }