最近觉着自己对java的一些高级用法不太了解，所以抽点时间来学习一下JUC锁机制。
本文要点：
- 共享锁和独占锁
- 独占锁中的公平锁和非公平锁
- 公平/非公平锁 获取机制
- 锁和synchronized的区别
1. 共享锁和独占锁
共享锁：顾名思义，是指一个锁能够被多个线程共享使用。
在java中，有类ReentrantReadWriteLock.ReadLock，CyclicBarrier，CountDownLatch，Semaphore
独占锁：是指一次只能被一个线程占用
在java中，有类ReentrantLock，ReentrantReadWriteLock.WriteLock
在java中，AQS->AbstractQueuedSynchronizer，是管理锁的抽象类，是独占锁和共享锁的公共父类。
2. 独占锁中的公平锁和非公平锁
公平锁：锁能够采用"公平"的策略分配给线程
非公平锁：锁首先采用"不公平"的策略来分配给线程，如果失败，则再采用"公平"的策略来分配锁。
所以，公平锁/非公平锁代表的是一种分配锁的机制、策略
3. 公平/非公平锁 获取机制
这里以ReentrantLock类来简单地分析一下这两种获取锁策略的实现原理：
首先，类ReentrantLock实现接口Lock，其内部有一个final类型的Sync抽象类。
private final Sync sync;
该类继承自AbstractQueuedSynchronizer抽象类
abstract static class Sync extends AbstractQueuedSynchronizer
个人理解，该类AbstractQueuedSynchronizer的就是一个基于FIFO队列而实现的同步器，或者说是独占锁机制的内部实现。
然后还是在ReentrantLock类内部，有两个内部类：NonfairSync和FairSync
static final class NonfairSync extends Sync
static final class FairSync extends Sync
从这两个内部静态类的名字中也可以猜到，他们的作用就代表着公平锁/非公平锁的实现机制。
那么接下来就简单分析一下从获取到释放锁的整个过程。
首先先看一下ReentrantLock的构造方法：
public ReentrantLock() {
sync = new NonfairSync();
}
ReentrantLock默认构造方法初始化一个非公平锁NonfairSync，采用非公平锁机制
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
当然也可以传入boolean来选择获取锁的机制。
ReentrantLock类初始化完成之后，首先调用lock方法
public void lock() {
sync.lock();
}
这个时候会根据sync的具体类型来调用不同的lock方法。
** 假如为公平锁FairSync，那么内部实现为 **
final void lock() {
acquire(1);
}
接下来再看acquire()方法
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
该acquire方法是在基类AbstractQueuedSynchronizer实现的。在该方法中，再调用一个tryAcquire来尝试获取锁：
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
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;
}
调用方法getState()获取当前锁的占用情况，如果c=0则说明当前锁没有线程占用，那么调用方法hasQueuedPredecessors来判断在AbstractQueuedSynchronizer中维护的FIFO队列是否还有线程,具体实现如下：
public final boolean hasQueuedPredecessors() {
// The correctness of this depends on head being initialized
// before tail and on head.next being accurate if the current
// thread is first in queue.
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());
}
如果在该队列中还有Node结点（即还有等待的线程），那么就返回true，否则返回false。
- 如果返回true,那么调用的方法
tryAcquire也就返回false,表示此次获取锁失败。接下来就执行方法addWaiter
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
该方法就是在FIFO队列的尾部新增一个Node结点，进而进行长路漫漫地排队等待。其实该结点就代表了这个线程。其中用到了CAS原子函数compareAndSetTail来将新增的Node设置为tail
执行完addWaiter方法之后，紧接着就执行方法acquireQueued
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);
}
}
该方法就是再一次去获取锁，只不过这一次是尝试给当前Node的上一个Node获取到锁，如果获取成功，则将当前Node设置为Head,否则继续阻塞等待。
至此回想一下，对于公平锁来说，整个获取过程大致为：
- 外部程序调用公平锁的
acquire(1)方法来获取锁 - 首先第一次调用
tryAcquire来尝试获取锁，其内部实现原理是通过查看FIFO队列是否还有线程等待来判断能够获取到锁 - 如果第一次尝试失败，则调用
addWaiter方法来将当前线程作为一个Node加入都FIFO队列的尾端。 - 加入到尾端之后，再一次调用
acquireQueued方法来查看尾端的上一个Node结点是否是首部并且能否获取到锁，如果可以，则该尾部节点升为头部节点，反之阻塞等待。
** 假如为非公平锁NonFairSync，那么内部实现为 **
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
与上边说的公平锁一对比就很容易发现，这里多了一个CAS函数compareAndSetState，它是一个原子操作，作用是比较并设置当前锁的状态。若锁的状态值为0，则设置锁的状态值为1。如果操作成功，则调用setExclusiveOwnerThread方法来让自己获取到锁。其实这两步操作就体现了非公平锁的获取机制
如果没能提前自己抢占到锁，那么就调用acquire(1)方法来获取了。接下来调用非公平锁的tryAcquire方法来尝试获取
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;
}
首先还是查看当前锁的state多少，如果为0，则再次调用CAS原子操作来抢占获取锁。如果该锁的state不为0， 则判断当前锁是不是自己持有的，如果是，则再次获取，并将state加1，否则返回false
接下来的过程就和公平锁的一样了，如果没有获取到锁，则加入到FIFO队列，然后判断上一个结点等等操作。
4. 独占锁锁和synchronized的区别
synchronized：在很多线程同时竞争一个资源的时候，即在资源竞争激烈的情况下，性能会很低。如果线程较少，则性能还可以。
独占锁：无论资源竞争是否激烈，性能都趋于平稳。其中的tryLock方法为非阻塞方法。
以上就是我对于JUC独占锁的一些学习和总结，但是需要承认的是，里面还有许多细节之处没有讲清楚，其实也是我没有理解。好吧，先掌握住大体的框架，然后最弄懂细节之处。记住，不要让一些繁琐的细节影响了你对整体的把握！