码迷,mamicode.com
首页 > 其他好文 > 详细

ReentrantLock 的公平锁源码分析

时间:2019-07-02 18:52:26      阅读:116      评论:0      收藏:0      [点我收藏+]

标签:一个   数据结构   表头   interrupt   执行   Owner   amp   res   public   

ReentrantLock 源码分析   以公平锁源码解析为例:

1:数据结构:

维护Sync 对象的引用:   private final Sync sync;

Sync对象继承 AQS,  Sync  分为两个类:处理公平锁锁和非公平锁:

FairSync   NonfairSync

 具体的类图如下:

  

2:接下来重点分析AQS这个类:AbstractQueuedSynchronizer:

AQS中的成员变量:

private transient volatile Node head;   //AQS维护队列的头结点

private transient volatile Node tail;     // AQS维护队列的尾结点

private volatile int state;                            // AQS 锁的状态  数量标识锁被获取的次数

下面看看NODE 结点的成员变量:

volatile int waitStatus;   //等待状态

volatile Node prev;      //前继节点

volatile Node next;      //后继节点

volatile Thread thread;   //线程对象

Node nextWaiter;       //下一个等待节点

从NODE的数据结构可以看出来,AQS里面维护的队列的数据结构是双链表的形式;

 
   

 

 

 

 

 

 

 

 

3:接下来分析 ReentrantLock  的构造方法:

ReentrantLock lock = new ReentrantLock(true);   //传入true,说明是构造公平锁

具体的构造方法如下,返回FairSync 对象:

public ReentrantLock(boolean fair) {

        sync = fair ? new FairSync() : new NonfairSync();

    }

4:lock方法的分析:因为是公平锁,所以调用 FairSync 下的lock方法:

final void lock() {

            acquire(1);

        }

   Acquire 的方法如下:

public final void acquire(int arg) {    // arg=1

        if (!tryAcquire(arg) &&    

            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

            selfInterrupt();

}

接下来分两种场景来分析tryAcquire(arg)  1:同一线程第一次或N次获取锁(其他线程没有获取到锁)   2:其他线程已经获取到锁,当前线程尝试去获取锁;

//场景 1:

protected final boolean tryAcquire(int acquires) {   // acquires=1

            final Thread current = Thread.currentThread();   //当前线程:main-thread

            int c = getState();    //如果为第一次获取锁c=0  如果main线程已经获取过锁,则c为加锁的次数

            if (c == 0) {     //当前线程第一次获取锁

                if (!hasQueuedPredecessors() &&  // hasQueuedPredecessor的分析如下单独分析:

                    compareAndSetState(0, acquires)) {  //cas原子操作 state=1

                    setExclusiveOwnerThread(current);  //独占线程设置为当前线程

                    return true;  //返回true表明加锁成功

                }

            }

            else if (current == getExclusiveOwnerThread()) {  // c=n 的情况下

                int nextc = c + acquires;    // nextc=n+1

                if (nextc < 0)

                    throw new Error("Maximum lock count exceeded");

                setState(nextc);    //设置 state=n+1

                return true;  //获取到锁,返回true

            }

            return false;

        }

说明:hasQueuedPredecessors主要是判断当前线程所在的节点是不是CLH队列的首个位置,这个判断的目的是公平锁的公平获取锁的机制

hasQueuedPredecessors的源码如下:以该线程是第一次获取锁为例分析:

public final boolean hasQueuedPredecessors() {

        Node t = tail;      // tail=null

        Node h = head;    // head=null

        Node s;

        return h != t &&    //返回false

            ((s = h.next) == null || s.thread != Thread.currentThread());

    }

 

//场景2 分析:有其他线程未释放锁(main-thread 持有锁,thread-1尝试去获取锁)

protected final boolean tryAcquire(int acquires) {   // acquires=1

            final Thread current = Thread.currentThread();   //当前线程:thread-1

            int c = getState();    // 由于其他持有锁 state 至少为1        

if (c == 0) {    

                if(!hasQueuedPredecessors()&&  compareAndSetState(0, acquires)) {                    

setExclusiveOwnerThread(current); 

                    return true;

                }

            }

            else if (current == getExclusiveOwnerThread()) {  // current=thread1  // getExclusiveOwnerThread()=main

                int nextc = c + acquires;                   

if (nextc < 0)

                    throw new Error("Maximum lock count exceeded");

                setState(nextc);   

                return true; 

            }

            return false;   //此时返回false表明尝试获取锁失败

        }

 

5:上面的场景1 获取到锁后返回true,则lock 方法执行结束。下面分析场景2:

public final void acquire(int arg) {

        if (!tryAcquire(arg) &&     //尝试获取锁失败,返回false

            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

            selfInterrupt();

    }

!tryAcquire(arg)  返回为true;接下来进入

acquireQueued(addWaiter(Node.EXCLUSIVE), arg))  这个逻辑;

这个方法有两层处理:

1:addWaiter(Node.EXCLUSIVE)   将当前线程调价到CLH队列中

2:acquireQueued();逐步执行CLH队列中的线程,如果当前线程获取到锁则返回,否则,当前线程进行休眠,直到唤醒并重新获取到锁才返回;

以下分析这两个方法:场景:main线程获取到锁但未释放,这是线程 thread-1去获取锁:(假设此时没有其他线程在CLH队列中,即CLH队列为null)

addWaiter(Node.EXCLUSIVE)方法:入参 Node.EXCLUSIVE 为null;

 

   private Node addWaiter(Node mode) {   //mode=null  EXCLUSIVE 标识节点为独占锁模型

        Node node = new Node(Thread.currentThread(), mode); //创建新节点:新节点中线程为当前线程,节点模型为独占锁:thread= thread-1   nextWaiter= mode

        // Try the fast path of enq; backup to full enq on failure

        Node pred = tail;   // 此时tail=null

        if (pred != null) {

            node.prev = pred;

            if (compareAndSetTail(pred, node)) {

                pred.next = node;

                return node;

            }

        }

        enq(node);  //进入enq方法

        return node;

    }

  Enq() 方法如下:

private Node enq(final Node node) {   //入参为上一步新建的节点

        for (;;) {

            Node t = tail;    // 第一次遍历逻辑 tail=null

            if (t == null) { // Must initialize

                if (compareAndSetHead(new Node()))  //CAS 创建表头 Head

                    tail = head;

            } else {

                node.prev = t;  //第二次遍历逻辑:node为上面新建的节点:thread= thread-1   nextWaiter= mode, node.prev指向表头 t 为表头

                if (compareAndSetTail(t, node)) {  //CAS设置队列尾节点为当前node

                    t.next = node;   // 表头后继节点指向当前节点

                    return t;

                }

            }

        }

}

该场景经过上面的处理之后 CLH队列的数据结构如下:

第一次遍历:

 Head,tail节点

 

 

 

 

 

 

 

 

 

 

 

第二次遍历:

   Head               当前线程node:设置为tail

 
   

 

 

 

 

 

 

 

 

接下来分析

acquireQueued这个方法

final boolean acquireQueued(final Node node, int arg) {  //node为当前线程节点 arg=1

        boolean failed = true;

        try {

            boolean interrupted = false; //当前线程在休眠时,有没有被中断过

            for (;;) {

                final Node p = node.predecessor(); //获取前继节点,这里为head节点

                if (p == head && tryAcquire(arg)) { //这里p== head为true,接下来进入

// tryAcquire(arg)这个方法,tryAcquire(arg)方法前面分析过了,这里返回false;

                    setHead(node);

                    p.next = null; // help GC

                    failed = false;

                    return interrupted;

                }

//   接下来会进入以下的逻辑:下面会分析这两个方法

                if (shouldParkAfterFailedAcquire(p, node) &&

                    parkAndCheckInterrupt())

                    interrupted = true;

            }

        } finally {

            if (failed)

                cancelAcquire(node);

        }

    }

 

这里再次回顾下tryAcquire(arg) 方法:返回fasle

protected final boolean tryAcquire(int acquires) {    // acquires=1

            final Thread current = Thread.currentThread(); //当前线程 thread-1

            int c = getState();   //state=1

            if (c == 0) {

                if (!hasQueuedPredecessors() &&

                    compareAndSetState(0, acquires)) {

                    setExclusiveOwnerThread(current);

                    return true;

                }

            }

            else if (current == getExclusiveOwnerThread()) {  // getExclusiveOwnerThread

获取到的线程是tryAcquire(int acquires)中设置的值 这里是 main; current=thread-1

                int nextc = c + acquires;

                if (nextc < 0)

                    throw new Error("Maximum lock count exceeded");

                setState(nextc);

                return true;

            }

            return false;

        }

    }

 

1): acquireQueued(final Node node, int arg) 方法中for循环第一次执行shouldParkAfterFailedAcquire(p, node) 方法分析:源码如下:

入参:pred为前继节点,这里是head  node为当前节点

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {

        int ws = pred.waitStatus;  // ws=0

        if (ws == Node.SIGNAL) 

                     return true;

        if (ws > 0) {

            do {

                node.prev = pred = pred.prev;

            } while (pred.waitStatus > 0);

            pred.next = node;

        } else {

            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);  //设置前继节点waitStatus= Node.SIGNAL,

        }

        return false;  //返回false;

    }

   For循环第二次执行 shouldParkAfterFailedAcquire(p, node)方法:

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {

        int ws = pred.waitStatus;  // ws=-1   在第一次已经设置为-1

        if (ws == Node.SIGNAL)   //返回true

                     return true;

        if (ws > 0) {

            do {

                node.prev = pred = pred.prev;

            } while (pred.waitStatus > 0);

            pred.next = node;

        } else {

            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);  //设置前继节点waitStatus= Node.SIGNAL,

        }

        return false;  //返回false;

    }

 

返回true后,接下进入parkAndCheckInterrupt()这个方法:

源码分析如下:

private final boolean parkAndCheckInterrupt() {

        LockSupport.park(this);  //阻塞当前线程

        return Thread.interrupted(); // 返回线程的中断状态

    }

LockSupport.park(this); //作用:前继线程节点的状态是 Node.SIGNAL;挂起当前线程;

Thread.interrupted(); //当前被挂起的线程被前继线程中断,返回线程的中断状态;

下面解释一个线程的行为:LockSupport.park(this)  线程被挂起:

当线程被挂起的时候唤醒的方式有两种:

1:unpark 的方式唤醒,前继节点线程使用完锁后,通过unpark方式唤醒当前线程

2:中断唤醒,其他线程通过 interrupt 中断当前线程

 

接下来继续分析:acquire(int arg)

public final void acquire(int arg) {

        if (!tryAcquire(arg) &&

            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

            selfInterrupt();

    }

这个时候的重点放在分析 selfInterrupt(); 这个方法上;

进入这个方法的条件是 当前线程被中断过,并且获取锁成功了;

static void selfInterrupt() {

        Thread.currentThread().interrupt();  //当前线程产生一个中断,真正被唤醒

    }

 

到此为止,ReentrantLock 的公平锁源码分析结束。

ReentrantLock 的公平锁源码分析

标签:一个   数据结构   表头   interrupt   执行   Owner   amp   res   public   

原文地址:https://www.cnblogs.com/beppezhang/p/11122200.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!