Java锁(二)：AbstractQueuedSynchronizer、ReentrantLock详解

已于 2022-03-30 15:10:20 修改
阅读量585 收藏
点赞数 1
分类专栏： Java锁 文章标签： java
于 2022-03-28 13:21:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34222160/article/details/123792998
版权

一、AbstractQueuedSynchronizer简介

AQS（AbstractQueuedSynchronizer）是并发容器JUC（java.util.concurrent）下locks包内的一个抽象类，是一个同步器，是用来构建锁或者其他同步组件的基础框架，内部维护了一个成员变量state表示同步状态，state=0表示线程未获取到锁，state > 0表示获取到锁，state > 1表示重入锁的数量，被 volatile修饰保证了可见性，通过CAS操作对其修改，内置维护了FIFO队列实现对未获取到锁的线程进行排队工作。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZJXLavYo-1648444823734)(https://qtspace.cn/contentimg/20.jpg)]

二、AbstractQueuedSynchronizer源码解析

核心成员变量
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer
    implements java.io.Serializable {
    
    /**
     * 等待获取锁队列的头节点, 只能通过setHead方法修改
     * 如果head存在保证waitStatus状态不为CANCELLED
     */
    private transient volatile Node head;


    /**
     * 等待获取锁队列的尾节点, 只能通过enq方法添加新的等待节点
     */
    private transient volatile Node tail;
    
    /**
     * 表示锁的状态
     * state = 0 表示未锁定
     * state > 0 表示已锁定
     * state > 1 表示可重入锁, 获取锁的次数
     * volatile修饰保证了可见性
     */
    private volatile int state;
}

AbstractQueuedSynchronizer主要有三个核心成员变量state、head、tail

  • state：表示锁的状态， 等于0表示未锁定，大于0表示已锁定，大于1表示可重入锁，重入锁的次数。被volatile修饰保证了可见性。
  • head：等待队列的头节点，除了初始化只能通过setHead()方法设置值，如果head存着能保证waitStatus状态不为CANELLED。
  • tail：等待队列尾节点，只能通过equ添加新的等待节点。
Node节点

AbstractQueuedSynchronizer内部维护着FIFO队列，也就是CLH队列，这个队列的每一个元素都是一个Node，所以我们接下来要了解其他其内部类Node，源码如下：

private static class Node {
    /**
     * 节点正在共享模式下等待的标记
     */
    static final Node SHARED = new Node();

    /**
     * 节点正在独占模式下等待的标记
     */
    static final Node EXCLUSIVE = null;

    /**
     * waitStatus变量的可选值, 取消状态, 被取消的节点不参与锁竞争, 状态也不会被改变
     */
    static final int CANCELLED = 1;

    /**
     * waitStatus变量的可选值, 下一节点处于等待状态, 如果当前节点释放锁或者被取消, 会通知下一节点去运行
     */
    static final int SIGNAL = -1;

    /**
     * waitStatus变量的可选值, 表示节点处于condition队列中, 正在等待被唤醒
     */
    static final int CONDITION = -2;

    /**
     * waitStatus变量的可选值, 下一次acquireShared应该无条件传播
     */
    static final int PROPAGATE = -3;

    /**
     * 节点的等待状态
     */
    volatile int waitStatus;

    /**
     * 上一节点
     */
    volatile Node prev;

    /**
     * 下一节点
     */
    volatile Node next;

    /**
     * 获取同步状态(锁)的线程
     */
    volatile Thread thread;

    /**
     * 下一个condition队列的等待节点
     */
    Node nextWaiter;

    /**
     * 是否是共享模式
     */
    final boolean isShared() {
        return nextWaiter == SHARED;
    }

    /**
     * 获取前一节点, 前一节点为null会抛异常
     */
    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null) {
            throw new NullPointerException();
        } else {
            return p;
        }
    }

    /**
     * 无参构造方法用于初始化头部或者共享模式标记
     */
    Node () {

    }

    /**
     * 用于addWaiter方法, 设置下一个condition队列的等待节点
     */
    Node(Thread thread, Node mode) {
        this.nextWaiter = mode;
        this.thread = thread;
    }

    /**
     * 用于addConditionWaiter方法
     */
    Node (Thread thread, int waitStatus) {
        this.thread = thread;
        this.waitStatus = waitStatus;
    }
}
核心方法

JUC里面的工具类基本都是基础AQS实现的，比ReentrantLock 、CountDownLatch、CyclicBarrier、Semaphore等，有的只支持独占锁，如ReentrantLock#lock()，有的支持共享锁，如Semaphore，从前文的Node类的定义也能看到

/**
 * 节点正在共享模式下等待的标记
 */
static final Node SHARED = new Node();

/**
 * 节点正在独占模式下等待的标记
 */
static final Node EXCLUSIVE = null;

AQS实现了两套加锁解锁的方式，那就是独占锁和共享锁。我们就从AQS最常用的类ReentrantLock来学习AQS的核心方法。

三、ReentrantLock

简介

ReentrantLock是基础AQS实现的一个可重入且独占式锁。内置了一个Sync同步器类实现了AQS，且支持公平锁和非公平锁，其实现类分别是FairSync和NonfairSync。

ReentrantLock所有操作都是通过核心内部类Sync操作，由子类FairSync和NonfairSync实现。

private final Sync sync;
ReentrantLock加锁过程
lock

lock()就是加锁，该方法定义如下：

public void lock() {
    sync.lock();
}

FairSync和NonfairSync具体实现：

// FairSync实现
final void lock() {
	acquire(1);
}

// NofairSync实现 setExclusiveOwnerThread是父类AQS
final void lock() {
    if (compareAndSetState(0, 1))
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}

protected final void setExclusiveOwnerThread(Thread thread) {
    exclusiveOwnerThread = thread;
}

可以看到非公平锁多了一个compareAndSetState()操作，通过CAS尝试修改锁状态state的值，如果修改成功设置当前线程以独占的方式获取了锁，修改失败执行的逻辑和公平锁一样。

公平锁和非公平锁获取独占锁的核心逻辑都是acquire()方法，接下来就看看这个方法。

acquire

acquire该方法是父类AbstractQueuedSynchronizer定义的方法，源码如下：

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

该方法主要调用tryAcquire方法尝试获取锁，成功返回true表示获取到了锁，如果失败就将线程封装成节点插入队尾。

tryAcquire

tryAcquire方法在类AbstractQueuedSynchronizer没有直接实现，采用模版方法的设计模式交给子类实现，先看公平锁FairSync的实现，源码如下：

protected final boolean tryAcquire(int acquires) {
    // 获取当前线程
    final Thread current = Thread.currentThread();
    // 获取当前锁状态 state=0表示未锁定, state>0表示已锁定
    int c = getState();
    if (c == 0) {
        // 线程没有获取到锁
        if (!hasQueuedPredecessors() &&
            compareAndSetState(0, acquires)) {
            // 没有比当前线程等待更久的线程了, 通过CAS的方式修改state
            // 如果成功则设置当前线程获取独占式锁
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    else if (current == getExclusiveOwnerThread()) {
        // 获取独占锁的线程就是当前线程, 表示重入
        // 重入锁的实现
        int nextc = c + acquires;
        if (nextc < 0)
            throw new Error("Maximum lock count exceeded");
        // 修改state记录获取锁的次数
        setState(nextc);
        return true;
    }
    return false;
}

从上面源码可以看出该方法就是独占的方式获取锁，获取成功后返回true，重入锁的逻辑也是在这里实现，主要通过修改state的值来记录获取锁的次数。

非公平锁的实现大同小异就是少了!hasQueuedPredecessors()的判断，因为是非公平锁嘛，所以不需要判断阻塞时间了。

acquire()方法除了调用tryAcquire()方法外还调用了acquireQueued(addWaiter(Node.EXCLUSIVE), arg)，这里有两个方法，我们先看addWaiter()方法。

addWaiter

该方法相当于把当前线程封装成一个节点Node，并加入队列，这个方法我们在上面有写过，源码如下：

/**
 * Creates and enqueues node for current thread and given mode.
 * 为当前线程和给定模式创建并设置尾节点
 * Node.EXCLUSIVE: 独占模式
 * Node.SHARED: 共享模式
 */
private Node addWaiter(Node mode) {
    // 为当前线程创建节点
    Npde node = new Node(Thread.currentThread(), mode);
    // 获取尾节点
    Node pred = tail;
    // Try the fast path of enq; backup to full enq on failure
    // 如果队列已经创建, 尝试快速添加尾结点
    if (pred == null) {
        node.prev = pred;
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    // 快速添加失败, 则调用enq
    enq(node);
    retur node;
}
enq

enq方法是将节点加入队列队尾，必要时要进行初始化，通过自旋+CAS的方式保证线程安全和插入成功。源码如下：

/**
* Inserts node into queue, initializing if necessary. See picture above
* 将节点插入队列，必要时进行初始化
*/
private Node enq(final Node node) {
    // 自旋
    for(;;) {
        // 获取尾节点
        Node t = tail;
        // 尾节点为null表示队列没有初始化
        if (t == null) {
            // 设置头节点
            if (compareAndSetHead(new Node())) {
                tail = head;
            }
        } else {
            // 队列已经初始化, 设置新添加节点的前一节点是队列的尾节点
            node.prev = t;
            // 设置尾节点
            if (compareAndSetTail(t, node)) {
                // 设置队列的尾节点的下一节点是新添加的节点, 新添加的节点就插入尾节点了
                t.next = node;
                return t;
            }
        }
    }
}

可以看出该方法就是往队列插入尾节点，通过自旋+CAS的方式，需要注意的是该方法返回的Node节点不是新插入的节点，而是新插入节点的前一节点。

enq()方法中调用的compareAndSetHead()、compareAndSetTail()方法如下：

/**
 * 通过CAS设置head值, 只在enq方法调用
 */
private final boolean compareAndSetHead(Node update) {
    return unsafe.companreAndSwapObject(this, headOffset, null, update);
}

/**
 * 通过CAS函数设置tail值，仅仅在enq方法中调用
 */
private final boolean compareAndSetTail(Node expect, Node update) {
    return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
}
acquireQueued

acquireQueued()方法作用就是获取锁，如果没有获取到锁就让当前线程阻塞等待，源码如下：

/**
 * 想要获取锁的acquire方法，都会通过这个方法获取锁
 * 循环通过tryAcquire方法不断去获取锁，如果没有获取成功
 * 就有可能调用parkAndCheckInterrupt方法，让当前线程阻塞
 * 结果返回true，表示在线程等待的过程中，线程被中断了
 */
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)) {
                // 将当前节点设置成头节点
                setHead(node);
                p.next = null;
                // 不需要调用cancelAcquire方法
                failed = false;
                return interrupted;
            }
            // 当前节点不是头节点或者没有获取到锁
            // shouldParkAfterFailedAcquire方法用于判断当前线程是否需要被阻塞
            // 当p节点的状态是Node.SIGNAL时就会调用parkAndCheckInterrupt方法阻塞线程
            // parkAndCheckInterrupt方法用于阻塞线程并且检测线程是否被中断
            // 被阻塞的线程有两种被唤醒的方法：
            // 1. 在unparkSuccessor(Node node)方法，会唤醒被阻塞的node线程，返回false
            // 2. 当前线程被调用了interrupt方法，线程被唤醒，返回true
            // 在这里只是简单地将interrupted = true，没有跳出for的死循环，继续尝试获取锁
            if (shouldParkAfterFailedAcquire(p, node) &&
               parkAndCheckInterrupt()) {
               interrupted = true;
            }
        }
    } finally {
        // failed为true，表示发生异常非正常退出
        if (failed) 
            // 将当前节点状态设置成CANCELLED, 表示当前节点已经被取消, 不需要唤醒了
            cancelAcquire(node);
    }
}

acquireQueued方法主要流程如下：

  1. 通过for(;;)死循环自旋，直到node（当前）节点获取到锁。
  2. 获取当前节点的前一个节点p。
  3. 如果节点p是头节点，然后调用tryAcquire()尝试获取锁，如果获取成功就将node节点设置成头节点然后返回。
  4. 如果节点p不是投节点或者获取锁失败，调用shouldParkAfterFaildAcquired()方法来决定是否要阻塞当前线程。
  5. 如果要阻塞当前线程，调用parkAndCheckInterrupt()方法阻塞当前线程。
  6. 如果当前线程发生异常，非正常退出，调用cancelAcquire()方法将当前节点的状态设置成取消。
shouldParkAfterFailedAcquire

shouldParkAfterFailedAcquire()用于判断当前线程是否需要阻塞，源码如下：

/**
 * 根绝前一个节点pred的状态来判断当前线程是否需要被阻塞
 */
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    // 获取前一节点的状态
    int ws = pred.waitStatus;
    if (ws == Node.SINGAL) {
        // 如果前一节点pred的状态是Node.SINGAL, 说明当前线程需要被阻塞
        return true;
    }
    if (ws > 0) {
        // 如果前一节点状态是Node.CANCELLED(大于0就是CANCELLED)
        // 表示前一节点所在线程已经被唤醒了, 要从队列中移除CANCELLED的节点
        // 所以从pred节点一直向前查找直到找到不是CANCELLED状态的节点, 并把该节点赋值给node的prev
        // 表示node节点的前一节点已经改变
        do {
            node.prev = pred = pred.prev;
        } while(pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 此时前一节点pred的状态只能是0或者PROPAGATE, 不可能是CONDITION状态
        // CONDITION(这个是特殊状态，只在condition列表中节点中存在，CLH队列中不存在这个状态的节点)
        // 将前一个节点pred的状态设置成Node.SIGNAL, 这样子下一次循环时,就是直接阻塞当前线程
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

这个方法是根绝前一个节点状态来判断当前线程是否需要被阻塞，前一节点的状态也是在这个方法中修改的，通过compareAndSetWaitStatus()方法。

shouldParkAfterFailedAcquire()方法主要流程如下：

  1. 如果前一节点状态是Node.SIGNAL，则直接返回true当前线程进入阻塞状态。
  2. 如果前一节点状态是Node.CANCELLED（大于0就是CANCELLED），表示前一个节点已经被唤醒了，要从队列中移动CANCELLED状态的节点，所以送pred节点一直向前查询不是CANCELLED状态的节点，并将该节点赋值成当前节点的前一节点，表示当前节点的前一节点发生变化，在acquireQueued()方法中进行下一次循环。
  3. 不是前面两种状态，只能是0或者PROPAGATE状态，修改前一节点的状态为Node.SIGNAL，下一次循环时阻塞当前线程。
parkAndCheckInterrupt

该方法用于阻塞当前线程并检测线程是否被中断，源码如下：

/**
 * 阻塞当前线程，线程被唤醒后返回当前线程中断状态
 */
private final boolean parkAndCheckInterrupt() {
	// 阻塞当前线程
    LockSupport.park(this);
    // 检测当前线程是否被中断（该方法会清除中断标识位）
    return Thread.interrupted();
}
cancelAcquire

cancelAcquire()方法在acquireQueued()方法异常的时候调用，用于将当前节点的状态设置成CANCELLED，源码如下：

// 将node节点的状态设置成CANCELLED，表示node节点所在线程已取消，不需要唤醒了。
private void cancelAcquire(Node node) {
    // 如果node为null，就直接返回
    if (node == null)
        return;

    //将获取锁节点的线程置空
    node.thread = null;

    // 跳过那些已取消的节点，在队列中找到在node节点前面的第一次状态不是已取消的节点
    Node pred = node.prev;
    while (pred.waitStatus > 0)
        node.prev = pred = pred.prev;

    // 记录pred原来的下一个节点，用于CAS函数更新时使用
    Node predNext = pred.next;

    // Can use unconditional write instead of CAS here.
    // After this atomic step, other Nodes can skip past us.
    // Before, we are free of interference from other threads.
    // 将node节点状态设置为已取消Node.CANCELLED;
    node.waitStatus = Node.CANCELLED;

    // 如果node节点是队列尾节点，那么就将pred节点设置为新的队列尾节点
    if (node == tail && compareAndSetTail(node, pred)) {
        // 并且设置pred节点的下一个节点next为null
        compareAndSetNext(pred, predNext, null);
    } else {
        // If successor needs signal, try to set pred's next-link
        // so it will get one. Otherwise wake it up to propagate.
        int ws;
        if (pred != head &&
            ((ws = pred.waitStatus) == Node.SIGNAL ||
             (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
            pred.thread != null) {
            Node next = node.next;
            if (next != null && next.waitStatus <= 0)
                compareAndSetNext(pred, predNext, next);
        } else {
            unparkSuccessor(node);
        }

        node.next = node; // help GC
    }
}
加锁过程总结

在这里插入图片描述

  1. 首先调用lock()方法，这个方法有两个子类FairSync和NofairSync实现，表示公平锁和非公平锁，两个类的不同就是NofairSync会直接调用compareAndSetStaus()方法修改加锁状态，如果成功当前线程获取到锁。
  2. 然后调用父类AbstractQueuedSynchronized的acquire()方法获取锁。
  3. acquire()方法调用tryAcquire()方法尝试获取锁，tryAcquire()由子类FairSync和NofairSync实现分别调用fairTryAcquire()和nonfairTryAcquire()方法尝试获取锁。这两个方法里面实现了重入锁的逻辑，如果当前锁状态是未获取到锁，则调用CAS设置锁状态，如果是获取到锁状态则会判断获取锁的线程是否是当前线程，如果是则是重入锁的逻辑记录当前线程获取锁的次数。
  4. 如果tryAcquire()方法调用获取锁失败，则会调用acquireQueued()方法再获取锁或者进入阻塞状态，acquireQueued()方法首先调用了addWaiter()方法用于将当前线程封装成一个节点加入队列队尾，然后再调用acquireQueued()方法获取锁或者进入阻塞状态，acquireQueued()方法会通过自旋的方式根绝当前节点状态判断是否进入阻塞状态。当别的线程释放锁的时候，可能唤醒这个线程，再调用tryAcquire()方法获取锁。
  5. 如果发生异常，将当前节点状态设置成CANCELLED。
ReentrantLock释放锁过程
unlock

调用unlock()方法释放锁，然后调用release()方法，源码如下：

public void unlock() {
    sync.release(1);
}
release

release是AbstactQueuedSynchronized定义的方法用于释放锁，源码如下：

/**
 * 在独占锁模式下, 释放锁
 */
public final boolean release(int arg) {
    // 调用tryRelease方法尝试释放锁, 由子类实现
    if (tryRelease(arg)) {
        //尝试释放锁成功 获取头节点
        Node h = head;
        // 如果头节点不为null且状态不为取消状态, 调用unparkSuccessor唤醒被阻塞的线程
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

release()释放锁流程如下：

  1. 调用tryRelease()方法尝试释放锁，返回true表示释放锁成功，返回false表示还持有锁资源。
  2. 如果释放锁成功了，且头节点不为null，就要唤醒被阻塞的线程，调用unparkSuccessor()方法唤醒一个等待的线程。
tryRelease

tryRelease尝试释放锁方法是有子类实现的，下面是ReentrantLock中Sync的tryRelease()方法实现：

protected final boolean tryRelease(int releases) {
    // c表示新的锁状态
    int c = getState() - releases;
    // 如果当前线程不是获取独占锁的线程抛错
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    // 是否可以释放锁
    boolean free = false;
    // 如果新的锁状态=0表示可以释放锁
    if (c == 0) {
        free = true;
        // 获取独占锁的线程置为null
        setExclusiveOwnerThread(null);
    }
    // 锁状态设置成未锁定
    setState(c);
    return free;
}

tryRelease()尝试释放锁流程如下：

  1. 首先获取新的锁状态
  2. 判断当前线程是否是获取独占锁的线程，如果不是抛异常。
  3. 如果新的锁状态是未锁定状态，获取独占锁的线程置为null，新的锁状态置为未锁定。
unparkSuccessor

unparkSuccessor()方法用于唤醒node节点下一节点非取消状态的节点所在线程，源码如下：

/**
 * 唤醒node节点下一节点非取消状态的节点所在线程
 */
private void unparkSuccessor(Node node) {
    // 获取node节点的状态
    int ws = node.waitStatus;
    // 如果状态小于0, 就将状态置为0, 表示这个node节点已经完成了
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    // 获取节点下一节点
    Node s = node.next;
    // 如果下一节点为null, 或者下一节点状态为取消状态, 就要寻找下一个非取消状态的节点
    if (s == null || s.waitStatus > 0) {
        // 先将s设置成null, s不是非取消状态的节点
        s = null;
        // 
        for(Node t = tail; t != null && t!= node; t = t.prev)
            //因为是从后向前遍历，所以不断覆盖找到的值，这样才能得到node节点后下一个非取消状态的节点
            if (t.waitStatus <= 0)
                s = t;
        // 如果s不为null，表示存在非取消状态的节点,那么调用LockSupport.unpark方法唤醒这个节点的线程	
        if (s != null)
            LockSupport.unpark(s.thread);
    }
}

unparkSuccessor()方法唤醒node节点的下一个非取消状态的节点所在线程流程如下：

  1. 先将node节点的状态设置为0。
  2. 寻找下一个状态不为取消的节点s。
  3. 如果节点s不为null，调用LockSupport.unpark()方法唤醒s所在线程。
释放锁过程总结

在这里插入图片描述

  1. 先调用tryRelease()方法尝试释放当前持有的锁资源。
  2. 如果成功释放了锁资源，则调用unparkSuccessor()方法去唤醒一个等待锁的线程。
四、总结

到这里ReentrantLock加锁释放锁的过程已经学习完毕，ReentrantLock是基于AQS实现的独占式锁，内部维护了一个FIFO队列实现未获取到锁的线程进行排队工作， ReentrantLock内部有FairSync（公平锁）和NonfairSync（非公平锁）两种实现，通过调用lock()方法加锁，调用unlock()方法解锁。

五、自己实现一个可重入的独占锁

通过继承AbstractQueuedSynchronizer类重写tryAcquire()和tryRelease()方法实现自定义的可重入独占锁。

代码如下：

public class SyncLock extends AbstractQueuedSynchronizer {

    @Override
    protected boolean tryAcquire(int acquires) {
        // 获取当前线程
        final Thread current = Thread.currentThread();
        // 获取当前锁状态
        int c = getState();
        // 如果锁状态为0, 表示当前锁是空闲的
        if (c == 0) {
            // 调用CAS原子操作设置锁状态
            if (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;
    }

    @Override
    protected 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;
    }

}

class AQSTest {
    public static void newThread(SyncLock syncLock, String name, int time) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程" + Thread.currentThread().getName() +
                        "开始运行, 准备获取锁。");
                syncLock.acquire(1);
                try {
                    System.out.println("线程" + Thread.currentThread().getName() + ", 在run方法获取了锁。");
                    lockAgain();
                    try {
                        Thread.sleep(time);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } finally {
                    System.out.println("线程"+Thread.currentThread().getName()+" 在run方法中释放了锁。");
                    syncLock.release(1);
                }
            }
            private void lockAgain() {
                syncLock.acquire(1);
                try {
                    System.out.println("线程" + Thread.currentThread().getName() + ", 在lockAgain方法获取了锁。");
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } finally {
                    System.out.println("线程"+Thread.currentThread().getName()+" 在lockAgain方法中释放了锁。");
                    syncLock.release(1);
                }
            }
        }, name).start();
    }

    public static void main(String[] args) {
        SyncLock syncLock = new SyncLock();
        newThread(syncLock, "t1111", 1000);
        newThread(syncLock, "t2222", 1000);
        newThread(syncLock, "t3333", 1000);
        newThread(syncLock, "t4444", 1000);
    }
}

上面代码测试结果如下：

线程t1111开始运行, 准备获取锁。
线程t2222开始运行, 准备获取锁。
线程t1111, 在run方法获取了锁。
线程t1111, 在lockAgain方法获取了锁。
线程t4444开始运行, 准备获取锁。
线程t3333开始运行, 准备获取锁。
线程t1111 在lockAgain方法中释放了锁。
线程t1111 在run方法中释放了锁。
线程t2222, 在run方法获取了锁。
线程t2222, 在lockAgain方法获取了锁。
线程t2222 在lockAgain方法中释放了锁。
线程t2222 在run方法中释放了锁。
线程t4444, 在run方法获取了锁。
线程t4444, 在lockAgain方法获取了锁。
线程t4444 在lockAgain方法中释放了锁。
线程t4444 在run方法中释放了锁。
线程t3333, 在run方法获取了锁。
线程t3333, 在lockAgain方法获取了锁。
线程t3333 在lockAgain方法中释放了锁。
线程t3333 在run方法中释放了锁。
六、ReentrentLock和synchronized的比较
相同点：
  • 都是加锁方式同步
  • 都是重入锁。
  • 都是通过阻塞的方式实现同步。
不同点
  • 原始构成：synchronized是java语言的关键字，是原生语法层面的互斥，由JVM实现，而ReentrentLock是JDK1.5之后提供的API层面的互斥锁。
  • 实现：synchronized是通过JVM实现加锁解锁，而ReentrentLock是API层面的加锁解锁，需要手动解锁。
  • 代码编写：synchronized不需要手动释放锁，修饰方法或者代码块，而ReentrentLock必须手动释放锁，如果没有释放锁可能造成死锁现象。需要lock()和unlock()方法配合try/finally语句块完成。
  • 灵活性：synchronized只能用于修饰方法或者代码块，灵活性低，而ReentrentLock是方法调用可以跨方法，灵活性高。
  • 是否等待可中断：synchronized不可中断，除非抛出异常，而ReentrentLock是可以中断的，如果持有锁的线程长期不释放锁，正在等待的线程可以选择放弃等待，通过设置超时时间方法。
  • 是否公平锁：synchronized是不公平锁，而ReentrentLock是可公平锁也可不公平锁。
  • 实现原理：synchronized是通过编译，会在同步代码块前后分别生成monitorenter和monitorexit两个指令实现同步，在执行monitorenter的指令时会尝试获取锁，获取锁成功会通过计数器+1，执行完毕之后会执行monitorexit执行计数器-1，当计数器为0时释放锁，如果获取锁失败就会进入阻塞状态，而ReentrentLock是通过CAS + CLH队列实现，通过CAS原子性操作实现对锁状态state的修改，通过CLH队列实现对未获取到锁的线程进行排队工作。
Java从零开始学多线程——6.Java 锁 Lock AbstractQueuedSynchronizer ReentrantLock acquireQueued NonfairSync tryA
JAVA求生之路——博主406766467
12-30 230
????锁的分类 自旋锁： 线程状态及上下文切换消耗系统资源，当访问共享资源的时间短，频繁上下文切换不值得。jvm实现，使线程在没获得锁的时候，不被挂起，转而执行空循环，循环几次之后，如果还没能获得锁，则被挂起 意思就是，当别的线程拿到锁进入方法执行的时候，别的锁进不来，但是他不能被挂起，开始执行空的for循环防止被挂起，如果循环完毕还没有得到锁，那么就会被挂起。 //自旋锁 public class Lock{ private boolean isLocked = false;
浅谈AbstractQueuedSynchronizer及ReentrantLock
thriveluo的博客
02-28 211
1、AbstractQueuedSynchronizer简要描述 是java.util.concurrent.locks包下的抽象类 jdk原始注释： Provides a framework for implementing blocking locks and related synchronizers (semaphores, events, etc) that rely on fi...
ReentrantLock对AbstractQueuedSynchronizer的使用
流的博客
09-19 276
1.ReentrantLock的骨架 由ReentrantLock的目录结构可知，ReentrantLock有三个内部类，Sync，FairSync，NonfairSync。 其中FairSync，NonfairSync继承了Sync，Sync继承了AbstractQueuedSynchronizer。 FairSync和NonfairSync也就是我们常说的公平锁和非公平锁。 公平锁和非公平锁的...
浅析同步队列器AbstractQueuedSynchronizer和ReentrantLock
zsxcomputer的博客
02-08 199
AbstractQueuedSynchronizer 队列同步器AbstractQueuedSynchronizer是整个JUC锁框架的基石，通过同步状态量state、CAS、ConditionObject等组件和一系列操作实现线程间的状态同步，也是CountDownLatch、Semaphore等并发工具的实现基础。 队列同步器包含下列核心组件： 1.同步变量state，volatile修饰，CAS操作更新，两者保证状态一致性； 2.内部类Node，代表竞争同步资源的线程节点，包含指向前后节点的引用，当存
AbstractQueuedSynchronizer之ReentrantLock
死磕各种源码
08-19 217
AQS：AbstractQueuedSynchronizer(字面翻译 抽象的 排队的 同步器，即同步器框架) AQS定义了多线程下，访问共享资源的同步器框架 AQS具备的特性： 阻塞等待队列 共享/独占 公平/非公平 可重入 允许中断 想象一下如果自己要实现一个锁机制，要能做到什么？ 同一时间，只有一个线程能访问到公共资源的功能。持有线程操作完以后，其他线程继续竞争 如果不用synchronized，如何实现呢？ 实现步骤： 2. 创建一个对象，对象中有如下属性： + 状态：记录当前是否有线程占用锁
（7）AbstractQueuedSynchronizer和ReentrantLock—— 可重入锁的实现
简易开头 快速迭代
09-27 315
目录 一、 可重入锁与非可重入锁 二、 公平锁与非公平锁 三、独占锁与共享锁 四、AbstractQueuedSynchronizer（AQS） 五、ReentrantLock 1. lock方法 2. tryAcquire方法 3. 可重入的实现 六、用AQS实现一个自己写的重入锁 一、 可重入锁与非可重入锁 可重入锁，就是当一个占有锁的线程再次进入到这个锁的...
Java中的显示锁ReentrantLock使用与原理详解
08-26
Java中的显示锁ReentrantLock使用与原理详解 Java中的显示锁ReentrantLock是Java concurrency API中的一种同步机制，用于解决多线程安全问题。ReentrantLock是Java 5中引入的，它是一种可重入锁，允许同一个线程多...
Java并发编程：ReentrantLock与读写锁详解
ReentrantLock继承自AbstractQueuedSynchronizer（AQS）框架，它的设计使得线程可以重入，即持有锁的线程可以再次获取同一把锁，这是内置锁不具备的特性。这在递归场景下非常有用，如递归调用时保持上下文一致。 ...
Java锁之AbstractQueuedSynchronizer
lemon
04-06 293
AbstractQueuedSynchronizer 一、AbstractQueuedSynchronizer 1.1 acquireQueued 同步队列中节点获取锁 当前节点的前继节点是头节点尝试获取锁，获取成功直接返回。 当前节点的前继节点不是头节点或者获取锁失败，判断当前线程是否应该Park 前继节点状态是Node.SIGNAL(当前继节点释放时会唤醒后继节点)，当前线程应该Park 前继...
Java锁——AbstractQueuedSynchronizer加锁和解锁分析
泯灭于众生，高歌于孤夜！
02-09 624
在java.util.concurrent.locks包中有很多Lock的实现类，常用的有ReentrantLock、ReadWriteLock（实现类ReentrantReadWriteLock），其实现都依赖java.util.concurrent.AbstractQueuedSynchronizer类，实现思路都大同小异，因此我们以ReentrantLock作为讲解切入点。 1. ReentrantLock的调用过程 经过观察ReentrantLock把所有Lock接口的操作都委派到一个Sync类上，
AbstractQueuedSynchronizer详解（二）同步器 与 ReentrantLock源码详细分析
小哥骑单车
07-24 3597
上一篇我们讲了AbstractQueuedSynchronizer（一）的大致流程： AbstractQueuedSynchronizer详解（一）同步器分析 现在来看一下ReentrantLock与他相关的详细源码分析： 目录 1、同步器类属性字段： 2、同步队列Node对象属性 3、获取ReentrantLock独占非公平锁 （1）、Reentr...
AbstractQueuedSynchronizer理解以及ReentrantLock和ReentrantReadWriteLock锁对AQS的实现
Jarvis's Blog
01-22 233
AQS整体架构与设计原则分析 AbstractQueuedSynchronizer（抽象的队列同步器），它是一个抽象类，所以一般使用它的时候都是写一个类来继承。它大部分代码都是基于Java来实现的。 本质上，AQS的与Synchronized在底层上的实现相似度能达到80%以上。synchronized 是独占锁，当一个线程获取到这把锁以后，其他线程无法获取到，只有等这个线程退出，释放掉锁之后，才能获取。 AQS的某些子类的实现，实现了读写锁的分离。对于一些数据的读取，我们对它上锁是没有必要的，这种锁我们称
Lock、ReentrantLock和AbstractQueuedSynchronizer的源码要点分析整理
kobejayandy的专栏
01-05 1664
前面已经说了很多Java并发和线程安全的东西，也提到并对比了内在锁和J.U.C包(java.util.concurrent包，后同)中Lock的锁。从这篇开始，对Java并发的整理从理论进入“实践”阶段，本篇对Lock、ReentrantLock和AbstractQueuedSynchronizer源码做简要分析和整理。先从Lock这个interface说起，然后分析ReentrantLock和A
ReentrantLock与AbstractQueuedSynchronizer源码解析
java线程池
07-30 396
在我们开发过程中，经常要和多线程打交道，多线程其实也是面试过程中必须问的问题，其实为什么会要使用多线程，这个大家可以百度下就清楚了。我们今天讲的这个ReentrantLock其实是对于同步（安全）的问题而产生的。大家应该都知道synchronized吧，他的作用业很简单，其实就是为了防止多线程下操作数据导致一些列问题，在1.5之前，其实都是基于这个synchronized的，而在jdk5的时候就推...
AbstractQueuedSynchronizer初始应用之ReentrantLock
简单，坚持
07-18 197
前面介绍的是排他申请锁的情况，也就是synchronized语法支持的内容。但是业务中会有更加复杂的场景，通过对tryAcquire、tryRelease的覆写以及state属性的使用，我们可以达到控制并发的目的，满足具体的场景需求。但是许多场景都是有共性的，并且直接使用这些底层的方法去实现并发，一来代码复杂，二来容易出错，所以有必要针对这些场景封装出通用的并发组件，比如Reetr...
Java 多线程与并发(11-26)-JUC锁- ReentrantLock详解.pdf
最新发布
07-26
Java中的ReentrantLock是Java并发包（java.util.concurrent.locks）中的一个高级锁，它是可重入的，意味着一个线程可以多次获取同一锁。在深入ReentrantLock之前，我们首先需要了解Java并发编程的基础，特别是Java...
Java并发------AbstractQueuedSynchronizer之ReentrantLock（一）
zajiayouzai的博客
12-26 185
一、AbstractQueuedSynchronizer AbstractQueuedSynchronizer 是 Java 并发包的基础工具类，是实现 ReentrantLock 等的基础。后面 AbstractQueuedSynchronizer 简称 AQS。 1、先说一下 ReentrantLock 的使用方法： public class OrderService { privat...
学习Java并发课程之AbstractQueuedSynchronized
zdl_csdn的博客
12-13 279
学习Java并发课程之AbstractQueuedSynchronized 简介： AbstractQueuedSynchronizer，即队列同步器。它是构建锁或者其他同步组件的基础框架（如ReentrantLock、ReentrantReadWriteLock、Semaphore等），是JUC并发包中的核心基础组件。AQS解决了实现同步器时涉及到的大量细节问题，例如获取同步状态、FIFO同步队列。基于AQS来构建同步器可以带来很多好处。它不仅能够极大地减少实现工作，而且也不必处理在多个位置上发生的竞争问
Java中的ReentrantLock与AbstractQueuedSynchronizer（AQS）关系以及原理（个人见解）
qq_41426990的博客
08-27 215
本文只是本人自己在阅读相关源码后的一些见解，希望可以帮到你
基于同步器AbstractQueuedSynchronizer 实现自定义锁
ZHANGYONGHAO604的博客
10-30 310
AbstractQueuedSynchronizer(AQS) 同步器 只是JAVA5 实现锁关建。利用同步器将所得语义(Semantic) 实现， 然后在自定义锁的实现中聚合AQS同步器。这里推荐一篇非常好的关于AQS的文章： http://ifeve.com/introduce-abstractqueuedsynchronizer/ 下面是自定锁的一个实现，其实就是Semphore, 令牌...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值