ReentrantLock源码解析

最新推荐文章于 2022-09-26 09:33:57 发布
最新推荐文章于 2022-09-26 09:33:57 发布
阅读量181 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hzau_itdog/article/details/106694024
版权

ReentrantLock继承体系

在这里插入图片描述

Lock接口中主要定义了 获取锁、尝试获取锁、释放锁、条件锁等几个方法。

构造方法

//非公平锁
public ReentrantLock() {
    sync = new NonfairSync();
}

//true公平锁，false非公平锁
public ReentrantLock(boolean fair) {
    sync = fair ? new FairSync() : new NonfairSync();
}

主要内部类

abstract static class Sync extends AbstractQueuedSynchronizer{}
static final class FairSync extends Sync {}
static final class NonfairSync extends Sync {}

抽象类Sync实现了AQS的部分方法；

NonfairSync实现了Sync，主要用于非公平锁的获取；

FairSync实现了Sync，主要用于公平锁的获取

在这里插入图片描述

lock方法分析

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

调用的同步器的lock方法。

FairSync的lock()

final void lock() {
    acquire(1);
}


//AbstractQueuedSynchronizer 的acquire
public final void acquire(int arg) {
    //尝试获取锁，如果失败了就加入队列排队。
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}


// ReentrantLock.FairSync.tryAcquire()
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;
}

hasQueuedPredecessors方法

public final boolean hasQueuedPredecessors() {
    //头结点不等于尾结点并且
    //头结点的下一个结点为空或者下个结点存储的线程不是当前线程
   	//也就是没有排队的线程
    Node t = tail; // Read fields in reverse initialization order
    Node h = head;
    Node s;
    return h != t &&
        ((s = h.next) == null || s.thread != Thread.currentThread());
    
}

获取锁失败加入队列

private Node addWaiter(Node mode) {
    //构建节点
    Node node = new Node(Thread.currentThread(), mode);
    Node pred = tail;
    //尾节点不为空，尝试把更新尾结点
    if (pred != null) {
        //新的尾结点的前一个节点设置为旧的尾结点
        node.prev = pred;
        //更新尾结点
        if (compareAndSetTail(pred, node)) {
            //更新成功设置旧尾结点的下一个结点为新的尾结点
            pred.next = node;
            //返回新节点
            return node;
        }
    }
    //尾结点为空，或者尝试加入新节点失败，就CAS自旋不断尝试直到成功。
    enq(node);
    return node;
}

private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        //尾结点为空初始化
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //CAS更新尾节点为新节点。
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                // 如果成功了，把旧尾节点的下一个节点指向新节点
                t.next = node;
                //返回新节点
                return t;
            }
        }
    }
}

//这个方法是尝试让对列中的节点依次来获取锁
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)) {
                 // 尝试获取锁成功
                // 这里同时只会有一个线程在执行，所以不需要用CAS更新
                // 把当前节点设置为新的头节点
                setHead(node);
                // 并把上一个节点从链表中删除
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            //前一个节点不是头结点，或者获取锁失败
            // // 是否需要阻塞
            if (shouldParkAfterFailedAcquire(p, node) &&
                // 真正阻塞的方法
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

// 第一次调用会把前一个节点的等待状态设置为SIGNAL，并返回false
// 第二次调用才会返回true
//static final int CANCELLED =  1;
//static final int SIGNAL    = -1;
//static final int CONDITION = -2;
//static final int PROPAGATE = -3;
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
      //  如果前一个节点的状态为SIGNAL(等待唤醒)，直接返回true
    if (ws == Node.SIGNAL)
        return true;
    // 如果前一个节点的状态大于0，也就是已取消状态
    if (ws > 0) {
         // 把前面所有取消状态的节点都从链表中删除
        /*
         * Predecessor was cancelled. Skip over predecessors and
         * indicate retry.
         */
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        // 如果前一个节点的状态小于等于0，则把其状态设置为等待唤醒
        // 这里可以简单地理解为把初始状态0设置为SIGNAL
        // CONDITION是条件锁的时候使用的
        // PROPAGATE是共享锁使用的
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}

获取锁的主要过程大致如下：

（1）没有排队的线程，就尝试获取锁尝试获取锁，如果获取到了就直接返回了；

（2）尝试获取锁失败，再调用addWaiter()构建新节点并尝试把新节点入队；

（3）入队失败则CAS循化更新尾结点直到入队成功。

（4）然后调用acquireQueued()再次尝试获取锁，如果成功了，直接返回；

（5）如果再次失败，再调用shouldParkAfterFailedAcquire()将节点的等待状态置为等待唤醒（SIGNAL）；

（6）调用parkAndCheckInterrupt()阻塞当前线程；

（7）如果被唤醒了，会继续在acquireQueued()的for()循环再次尝试获取锁，如果成功了就返回；

（8）如果不成功，再次阻塞，重复（4）（5）（6）直到成功获取到锁。

以上就是整个公平锁获取锁的过程。

独占式同步状态的获取流程
在这里插入图片描述

NonfairSync的lock()

// ReentrantLock.lock()
public void lock() {
    sync.lock();
}
// ReentrantLock.NonfairSync.lock()
// 这个方法在公平锁模式下是直接调用的acquire(1);
final void lock() {
    // 直接尝试CAS更新状态变量
    if (compareAndSetState(0, 1))
        // 如果更新成功，说明获取到锁，把当前线程设为独占线程
        setExclusiveOwnerThread(Thread.currentThread());
    else
        acquire(1);
}
//AbstractQueuedSynchronizer 的acquire
public final void acquire(int arg) {
    //尝试获取锁，如果失败了就加入队列排队。
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}
// ReentrantLock.NonfairSync.tryAcquire()
protected final boolean tryAcquire(int acquires) {
    // 调用父类的方法
    return nonfairTryAcquire(acquires);
}
// ReentrantLock.Sync.nonfairTryAcquire()
final boolean nonfairTryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 如果状态变量的值为0，再次尝试CAS更新状态变量的值
        // 相对于公平锁模式少了!hasQueuedPredecessors()条件
        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;
}

相对于公平锁，非公平锁加锁的过程主要有两点不同：

（1）一开始就尝试CAS更新状态变量state的值，如果成功了就获取到锁了；

（2）在tryAcquire()的时候没有检查是否前面有排队的线程，直接上去获取锁才不管别人有没有排队呢；

总的来说，相对于公平锁，非公平锁在一开始就多了两次直接尝试获取锁的过程。
tryLock()方法

尝试获取一次锁，成功了就返回true，没成功就返回false，不会继续尝试。

// ReentrantLock.tryLock()
    public boolean tryLock() {
        return sync.nonfairTryAcquire(1);
    }
// ReentrantLock.Sync.nonfairTryAcquire()
 final boolean nonfairTryAcquire(int acquires) {
     final Thread current = Thread.currentThread();
     int c = getState();
     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;
 }

tryLock()方法比较简单，直接以非公平的模式去尝试获取一次锁，获取到了或者锁本来就是当前线程占有着就返回true，否则返回false。

tryLock(long time, TimeUnit unit)方法

尝试获取锁，并等待一段时间，如果在这段时间内都没有获取到锁，就返回false。

// ReentrantLock.tryLock()   
public boolean tryLock(long timeout, TimeUnit unit)
            throws InterruptedException {
    return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
// AbstractQueuedSynchronizer.tryAcquireNanos()
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
    throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
     
// 先尝试获取一次锁
    return tryAcquire(arg) ||
        doAcquireNanos(arg, nanosTimeout);
}
// AbstractQueuedSynchronizer.doAcquireNanos()

private boolean doAcquireNanos(int arg, long nanosTimeout)
    throws InterruptedException {
    if (nanosTimeout <= 0L)
        return false;
    //到期时间
    final long deadline = System.nanoTime() + nanosTimeout;
    final Node node = addWaiter(Node.EXCLUSIVE);
    boolean failed = true;
    try {
        for (;;) {
            final Node p = node.predecessor();
            if (p == head && tryAcquire(arg)) {
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return true;
            }
            nanosTimeout = deadline - System.nanoTime();
             
		// 如果时间到了，就直接返回
            if (nanosTimeout <= 0L)
                return false;
              
            // spinForTimeoutThreshold = 1000L;       
            // 只有到期时间大于1000纳秒，才阻塞        
            // 小于等于1000纳秒，直接自旋解决就得了

            if (shouldParkAfterFailedAcquire(p, node) &&
                nanosTimeout > spinForTimeoutThreshold)
                LockSupport.parkNanos(this, nanosTimeout);
            if (Thread.interrupted())
                throw new InterruptedException();
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}

unlock()方法

// java.util.concurrent.locks.ReentrantLock.unlock()
public void unlock() {
    sync.release(1);
}
// java.util.concurrent.locks.AbstractQueuedSynchronizer.release
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        // 如果头节点不为空，且等待状态不是0，就唤醒下一个节点
        // 在每个节点阻塞之前会把其上一个节点的等待状态设为SIGNAL（-1）
        // 所以，SIGNAL的准确理解应该是唤醒下一个等待的线程
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

// java.util.concurrent.locks.ReentrantLock.Sync.tryRelease
protected final boolean tryRelease(int releases) {
    int c = getState() - releases;
     
	// 如果当前线程不是占有着锁的线程，抛出非法监视器异常异常
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    boolean free = false;
    // 如果状态变量的值为0了，说明完全释放了锁
    
    // 这也就是为什么重入锁调用了多少次lock()就要调用多少次unlock()的原因

    // 如果不这样做，会导致锁不会完全释放，别的线程永远无法获取到锁
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    setState(c);
    return free;
}

// java.util.concurrent.locks.AbstractQueuedSynchronizer.unparkSuccessor
private void unparkSuccessor(Node node) {
 	 //node是头节点
    int ws = node.waitStatus;
    // 如果头节点的等待状态小于0，就把它设置为0
    //static final int CANCELLED =  1;
    //static final int SIGNAL    = -1;
    //static final int CONDITION = -2;
    //static final int PROPAGATE = -3;
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    Node s = node.next;
     
// 如果下一个节点为空，或者其等待状态大于0（实际为已取消）
    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);
}

释放锁的过程大致为：

（1）将state的值减1；

（2）如果state减到了0，说明已经完全释放锁了，唤醒下一个等待着的节点；

条件锁

一般这么用

public static void main(String[] args) {
    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    new Thread(() -> {
        try {
            lock.lock();

            condition.await();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

    }).start();

    try {
        Thread.sleep(1000);
        lock.lock();
        condition.signal();
    } catch (InterruptedException e) {
        e.printStackTrace();
    }finally {
        lock.unlock();
    }
}

lock.newCondition()方法

新建一个条件锁。

// ReentrantLock.newCondition()
public Condition newCondition() {
    return sync.newCondition();
}
// ReentrantLock.Sync.newCondition()
final ConditionObject newCondition() {
    return new ConditionObject();
}
// AbstractQueuedSynchronizer.ConditionObject.ConditionObject()
public ConditionObject() { }

ConditionObject的主要属性

 private static final long serialVersionUID = 1173984872572414699L;
 /** First node of condition queue. */
 private transient Node firstWaiter;
 /** Last node of condition queue. */
 private transient Node lastWaiter;

// AbstractQueuedSynchronizer.ConditionObject.await()
public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //添加节点到条件队列（和AQS队列不同）中，
    Node node = addConditionWaiter();
    //完全释放当前线程所占的锁
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    //是否在同步队列中
    while (!isOnSyncQueue(node)) {
        //阻塞当前线程
        LockSupport.park(this);
             // 上面部分是调用await()时释放自己占有的锁，并阻塞自己等待条件的出现
        // *************************分界线*************************  //
        // 下面部分是条件已经出现，尝试去获取锁
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    // 尝试获取锁,如果没有获取到则阻塞
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
        // 清除取消的节点
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    // 线程中断相关
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

// AbstractQueuedSynchronizer.ConditionObject.addConditionWaiter
private Node addConditionWaiter() {
    Node t = lastWaiter;
    // If lastWaiter is cancelled, clean out.
    //如果队列的尾结点已取消，从头节点开始清除取消的结点。
    if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();
        //重新获取尾结点
        t = lastWaiter;
    }
    //构建尾结点
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    //条件队列为空，首节点就是node
    if (t == null)
        firstWaiter = node;
    //否则旧的尾结点的下个结点是node
    else
        t.nextWaiter = node;
    //返回新的尾结点
    lastWaiter = node;
    return node;
}

// AbstractQueuedSynchronizer.ConditionObject.unlinkCancelledWaiters
private void unlinkCancelledWaiters() {
    Node t = firstWaiter;
    Node trail = null;
    while (t != null) {
        Node next = t.nextWaiter;
        //如果当前节点已取消
        if (t.waitStatus != Node.CONDITION) {
            //断开首节点
            t.nextWaiter = null;
            if (trail == null)
                firstWaiter = next;
            //
            else
                trail.nextWaiter = next;
            if (next == null)
                lastWaiter = trail;
        }
        //当前节点未取消，则首节点为当前节点的下个结点
        else
            trail = t;
        t = next;
    }
}

unlinkCancelledWaiters 作用断开所有是cancelled的结点。

//完全释放锁
final int fullyRelease(Node node) {
    boolean failed = true;
    try {
        // 获取状态变量的值，重复获取锁，这个值会一直累加
        // 所以这个值也代表着获取锁的次数
        int savedState = getState();
         // 一次性释放所有获得的锁
        if (release(savedState)) {
            failed = false;
             // 返回获取锁的次数
            return savedState;
            //释放失败！上锁且释放失败，必是异常的发生
        } else {
            throw new IllegalMonitorStateException();
        }
    } finally {
        //完全释放失败则标记尾结点为CANCELLED
        if (failed)
            node.waitStatus = Node.CANCELLED;
    }
}

// AbstractQueuedSynchronizer.isOnSyncQueue
final boolean isOnSyncQueue(Node node) {
    // 如果等待状态是CONDITION，或者前一个指针为空，返回false
    // 说明还没有移到AQS的队列中
    if (node.waitStatus == Node.CONDITION || node.prev == null)
        return false;
    // 如果next指针有值，说明已经移到AQS的队列中了
    if (node.next != null) // If has successor, it must be on queue
        return true;
    // 从AQS的尾节点开始往前寻找看是否可以找到当前节点，找到了也说明已经在AQS的队列中了
    return findNodeFromTail(node);
}
//从AQS的尾节点开始往前寻找看是否可以找到当前节点
private boolean findNodeFromTail(Node node) {
    Node t = tail;
    for (;;) {
        if (t == node)
            return true;
        if (t == null)
            return false;
        t = t.prev;
    }
}

await()方法的大致流程：

（1）新建一个节点加入到条件队列中去；

（2）完全释放当前线程占有的锁；

（3）阻塞当前线程，并等待条件的出现；

（4）条件已出现（此时节点已经移到AQS的队列中），尝试获取锁；

condition.signal()方法

// AbstractQueuedSynchronizer.ConditionObject.signal
public final void signal() {
    // 如果不是当前线程占有着锁，调用这个方法抛出异常
    // 说明signal()也要在获取锁之后执行
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    // 条件队列的头节点
    Node first = firstWaiter;
    // 如果有等待条件的节点，则通知它条件已成立
    if (first != null)
        doSignal(first);
}
// AbstractQueuedSynchronizer.ConditionObject.doSignal
private void doSignal(Node first) {
    do {
        // 移到条件队列的头节点往后一位
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        // 相当于把头节点从队列中出队
        first.nextWaiter = null;
        // 转移节点到AQS队列中
    } while (!transferForSignal(first) &&
             (first = firstWaiter) != null);
}
// AbstractQueuedSynchronizer.transferForSignal
final boolean transferForSignal(Node node) {
    // 把节点的状态更改为0，也就是说即将移到AQS队列中
    // 如果失败了，说明节点已经被改成取消状态了
    // 返回false，通过上面的循环可知会寻找下一个可用节点
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;

    // 调用AQS的入队方法把节点移到AQS的队列中
    // 注意，这里enq()的返回值是node的上一个节点，也就是旧尾节点
    Node p = enq(node);
    // 上一个节点的等待状态
    int ws = p.waitStatus;
    // 如果上一个节点已取消了，或者更新状态为SIGNAL失败（也是说明上一个节点已经取消了）
    // 则直接唤醒当前节点对应的线程
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    // 如果更新上一个节点的等待状态为SIGNAL成功了
    // 则返回true，这时上面的循环不成立了，退出循环，也就是只通知了一个节点
    // 此时当前节点还是阻塞状态
    // 也就是说调用signal()的时候并不会真正唤醒一个节点
    // 只是把节点从条件队列移到AQS队列中
    return true;
}

signal()方法的大致流程为：

（1）从条件队列的头节点开始寻找一个非取消状态的节点；

（2）把它从条件队列移到AQS队列；

（3）且只移动一个节点；

hzau_itdog
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ReentrantLock源码解析（二）
12-21
《ReentrantLock源码解析（二）》 在Java并发编程中，ReentrantLock是一个重要的同步工具类，它提供了一种比synchronized更细粒度的锁控制机制。本文主要探讨ReentrantLock的内部实现，特别是其数据结构和关键方法...
ReentrantLock源码分析
12-26
近日，阅读jdk并发包源码分析整理笔记。
ReentrantLock 源码
老男孩的架构路
09-26 753
ReentrantLock 中的 lock 方法，主要调用内部类 Sync 中的抽象 lock 方法。该方法主要有两套实现，一套是公平锁，一套是非公平锁。
ReentrantLock的源码分析
雅俗共赏的博客
01-19 536
ReentrantLock的公平锁和非公平锁的具体实现及其区别
ReentrantLock 源码分析
a410215373的专栏
05-23 145
1.你想知道锁是怎么做的吗？ 2.你想知道重入锁是什么吗？ 3.你想知道当一个线程持有锁后，其他线程是怎么被挂起的吗 4.如果在阻塞过程中线程被中断或关闭怎么办 5.你想知道线程是怎么释放锁的吗 6.线程释放锁之后，怎么唤起其他线程的。 带着问题，我们开始看源码 这张类图，我就看懂了 ReentrantLock 是实现 Lock 的，其他不知道。 当我们创建Reen...
ReentrantLock 源码简单分析
lhx574938077的博客
03-08 252
JAVA中锁的实现最常见的方式有两种，一种是 synchronized关键字，一种是Lock。实际的开发过程中，要对这两种方式进行取舍。 synchronized是基于JVM层面实现的， Lock却是基于JDK实现的。 synchronized是一个关键字，使用简单，锁粒度粗。Lock相对复杂，需要释放，锁粒度自由。Lock功能相对强大，如下表。 tips ...
第六章 ReentrantLock源码解析2--释放锁unlock()1
08-04
ReentrantLock源码解析之释放锁unlock() ReentrantLock是一个可重入锁，它提供了一个unlock()方法来释放锁。在本章中，我们将深入探讨unlock()方法的源码，了解其释放锁的步骤和机制。 unlock()方法的主要作用是...
ReentrantLock 源码解析
最新发布
05-25
下面是ReentrantLock的源码解析： ReentrantLock的实现基于AbstractQueuedSynchronizer（简称AQS），AQS提供了一种同步框架，可以用来实现各种类型的同步器。ReentrantLock是AQS提供的其中一种同步器。 在...
ReentrantLock源码
zhangshng的博客
08-13 206
Java的内置锁一直都是备受争议的，在JDK 1.6之前，synchronized这个重量级锁其性能一直都是较为低下，虽然在1.6后，进行大量的锁优化策略,但是与Lock相比synchronized还是存在一些缺陷的：虽然synchronized提供了便捷性的隐式获取锁释放锁机制（基于JVM机制），但是它却缺少了获取锁与释放锁的可操作性，可中断、超时获取锁，且它为独占式在高并发场景下性能大打折扣。...
ReentrantLock的源码详解
u011743212的博客
05-25 300
ReentrantLock reentrantLock = new ReentrantLock(); 创建一个非公平锁 public ReentrantLock() { sync = new NonfairSync(); } 调用的锁的lock方法 reentrantLock.lock(); 调用NonfairSync的lock方法 final void lock() { // state是否等于0,等于0,把它的值设..
ReentrantLock源码学习
秃头哥编程
11-26 604
学习ReentrantLock之前，先了解一下可重入锁的概念。何为可重入锁，顾名思义，就是可重入的。真是听君一席话，胜听一席话啊。 正经点，可重入锁就是能够支持同一个线程对资源的重复加锁。注意两个关键字：同一线程和重复。 像synchronized关键字也实现了可重入。用synchronized修饰的方法，在进行递归调用时，执行线程在获取了锁之后仍然能够连续多次获得该锁，并不会出现阻塞的情况。 再比如说，这篇文章要学习的ReentrantLock，也实现了可重入锁。并且ReentrantLock还支持公平
ReentrantLock源码分析(AQS)
chy_want的博客
04-27 287
1.结构 ReentrantLock 类内定义了抽象类Sync，以及实现抽象类的NonfairSync和FairSync，重写了lock和tryAcquire(非公平锁直接去调用了抽象类实现的)方法。 Sync 这边我们可以看到Sync是基于AbstractQueuedSynchronizer实现的。 abstract static class Sync extends AbstractQueuedSynchronizer { private static final long serialV
ReentrantLock源码简单分析
之城的专栏
05-11 3431
ReentrantLock 能用于更精细化的加锁的Java类, 通过它能更清楚了解Java的锁机制 ReentrantLock 类的集成关系有点复杂, 既有内部类, 还有多重继承关系
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值