AQS同步器代码分析

AQS原理代码分析

特点：可重入锁，有公平锁、非公平锁区分，默认非公平锁。

大概逻辑：

1. 修改成功并获得锁
2. 加入到等待队列
   1. Node1、Node2、Node3、…
3. 让等待队列线程挂起
   1. LockSuport.part(next); 阻塞挂起
4. 响应
   1. 唤醒挂起的线程。LockSuport.unpart(next);

Lock代码分析

//非公平锁
ReentrantLock rLock = new ReentantLock();
rLock.lock();


//方法
 final void lock() {
    		 //线程进来首先会进行CAS操作抢占锁，如果抢占成功，则将当前线程设置为独占锁
            if (compareAndSetState(0, 1)) {
                setExclusiveOwnerThread(Thread.currentThread()); 
            }else {
               acquire(1); 
            }
                
    }

/**
* CAS抢占成功，则设置当前线程以独占方式进行运行
*/
protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

1. 线程进来首先会进行CAS操作抢占锁，如果抢占成功，则将当前线程设置为独占锁，如果失败，则进行 acquire(1) 操作

2. acquire(1) : 采用自旋的方案将自身线程设置为Node并插入同步队列

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

/**
* 将当前线程作为Node创建节点并插入同步队列尾部
*/
private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);	//当前线程Node节点信息
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail; //tail是AQS中表示队列尾部的属性，如果同步队列中有数据不为null，反之亦然
        if (pred != null) {	//队列中有数据，则不为空
            node.prev = pred; //将自身的Prev节点信息，设置为上一个节点的信息
            if (compareAndSetTail(pred, node)) { //通过CAS操作，将队列中已存在的节点在next属性设置为当前节点，并返回
                pred.next = node;
                return node;
            }
        }
    
    	//以自旋的方式将Node节点插入同步队列，并进行初始化：  pre、Next的信息
        enq(node);
        return node;
    }

/**
* 以自旋的方式将Node节点插入同步队列，如果队列中无数据，则先进行初始化 否则 修改自身的pre、Next的信息
*/
private Node enq(final Node node) {
        for (;;) {
            Node t = tail;
            if (t == null) { // Must initialize,如果同步队列中无数据，则先初始化
                if (compareAndSetHead(new Node())) //CAS操作队列尾部数据为自身节点Node
                    tail = head;
            } else { 
                node.prev = t; //自身Prev设置为为队列中最后一个尾部Node
                if (compareAndSetTail(t, node)) { //同步队列中有数据，则通过CAS将队列中尾部的节点Next属性更改为当前自身节点Node
                    t.next = node;
                    return t;
                }
            }
        }
    }

/**
*自旋的方式获取锁，如果获取锁成功，则返回，并将自身Node节点移出同步队列，假如获取锁失败，则将当前线程进行暂停挂起
*/
final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();	//获取当前Pre的节点信息
                if (p == head && tryAcquire(arg)) { //如果head为null,则代表有机会进行抢占锁
                    setHead(node);	//获取锁成功，将队列头设置为节点，使其出列，并将自身的thread、prev置为null		
                    p.next = null; // help GC
                    failed = false;	//把原来的节点进行删除
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) && //更新未获取到锁线程的状态为-1
                    parkAndCheckInterrupt()) //线程暂停，并返回是否中断状态
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

/**
* 将当前线程暂停
*/
static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }