ReentrantLock实现公平锁和非公平锁

abstract void lock();
公平锁： FairSync ； 非公平锁：NonfairSync

ReentrantLock默认非公平锁，通过 new ReentrantLock(true)实现公平锁

非公平锁实现过程

ReentrantLock lock = new ReentrantLock();
lock.lock();

调用同步器的lock方法

public void lock() {
   //调用Sync同步器的lock方法
   sync.lock();
}

sync.lock()有两个实现，一个是FairSync公平锁，一个是NonfairSync非公平锁

final void lock() {
	//通过cas尝试修改state，修改成功执行加锁
	if (compareAndSetState(0, 1)){
	 	setExclusiveOwnerThread(Thread.currentThread());
	}else{
		//加锁失败，尝试独占式加锁
		acquire(1);
	}              
}

首先判断是否是重入锁，不是重入锁尝试cas加锁，重入锁则先判断当前线程是否是该锁的持有者。

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");
        }
        //设置新的state
        setState(nextc);
        return true;
    }
    return false;
}

公平锁

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

public final void acquire(int arg) {
	if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        //阻塞当前线程
    	selfInterrupt();
}

判断是否是重入锁

• 非重入
  是否是队列头节点&&cas尝试加锁
• 重入
  nextc小于0，超过最大锁定计数。大于0设置新的state，加锁成功

 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;
        }

这一段可以这样理解，A,B,C,D四个线程。A线程获取到了锁，并且一直持有。这时候如果B来执行加锁会失败进入队列，并且作为第一个等待节点。C，D两个线程会依次进入队列中。A释放锁以后，会唤醒等待队列第一个节点，也就是B，后续依次执行队列中的下一个等待头节点

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; // help GC
                    failed = false;
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

获取锁失败后判断是否需要park

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        //前驱节点状态判断是SIGNAL，那么说明本节点需要被唤醒，返回true,这里返回true以后就能运行后面的parkAndCheckInterrupt方法
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             */
            return true;
        说明前驱节点是取消状态，则往前遍历，直到找到前驱几点状态是非取消的节点为止。返回false,不park，继续尝试获取锁。如果获取失败再次进入到次方法中，如果是signal那么就执行上面逻辑，如果是其他小于等于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或者是传播模式。那么设置前驱节点状态是signal，返回false，不park。继续尝试获取锁。
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;
    }