一，AQS
AbstractQueuedSynchronizer，定义了一套多线程访问共享资源的同步器框架，依赖于状态的同步器
1，ReentrantLock
一种基于AQS框架的应用实现，类似于synchronized是一种互斥锁，可以保证线程安全。它支持手动加锁与解锁，支持加锁的公平性。主要是Lock锁的实现
public class ReentrantLock implements Lock, Serializable
接下来可以手动的猜想一下这个reentrantLock的实现
ReentrantLock lock = new ReentrantLock(true); HashSet hashSet = new HashSet(); 3个线程 T0,T1,T2 lock.lock(); //加锁 while(true){ //循环，轮询获取锁 if(加锁成功){ //synchronized,cas cas:compare and swap break;//跳出循环 } //Thread.yeild() //让出cpu使用权 //Thread.sleep(1000); //睡眠 hashSet.add(thread); //将当前线程加入到set中 //阻塞 LockSupprot.park(); } T0获取锁 xxxxx业务逻辑 xxxxx业务逻辑 lock.unlock(); Thread thread = hashSet.get(); //唤醒当前线程，notify是唤醒随机的线程 LockSupport.unPark(thread);
三大核心：自旋，加锁，LockSupport，队列(LinkQueue)，为了解决这个公平锁和非公平锁，因此优先考虑这个队列。
2，CAS
compare and swap，比较与交换
如在jmm模型中，两个工作内存都去修改主内存的值。主内存中存在一个a = 0，线程A和线程B的工作内存同时获取到这个值，如果线程A先修改这个值，则线程A会和主内存比较，如果线程A的值a和主内存的值一致，那么就会直接进行修改，如改成a = 1，那么线程B也要改这个值，线程B中的a = 0，那么会和主内存a比较，发现不一致，主内存a=1，那么就会优先将线程B中的值修改成a = 1，再对a进行修改。就是说相等直接修改，不相等需要重新读取，再进行修改。即在一个原子操作里面进行比较和替换
主要通过这个unsafe类实现，里面的实现也是原子类操作，主要是通过以下三个类实现。
//对象类型 public final native boolean compareAndSwapObject(Object var1, long var2, Object var4, Object var5); //整型值 public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5); //Long型值 public final native boolean compareAndSwapLong(Object var1, long var2, long var4, long var6);
3，AbstractQueuedSynchronizer
该类是ReentrantLock里面的一个抽象内部类。ctrl + alt + shift + u看所有子类，Ctrl + T，看所有的继承类，可以发现很多地方都继承或者实现了这个抽象类
Sync是ReentrantLock的一个抽象的静态内部类，根据图也可以发现这个Sync继承了这个AQS
abstract static class Sync extends AbstractQueuedSynchronizer
通过实现Sync这个接口得到了FairSync公平锁类和NofairSync非公平锁这个类
3.1，FairSync
实现了公平锁，需要排队获取锁，如存在线程t1，t2，t3依次获取锁，需要依次排队执行，突然来了一个线程t4，也是需要排在线程t3后面
ReentrantLock reentrantLock = new ReentrantLock(true); public ReentrantLock(boolean fair) { //入参，用于判断是公平锁还是非公平锁 sync = fair ? new FairSync() : new NonfairSync(); } //公平锁的实现 static final class FairSync extends ReentrantLock.Sync{...}
公平锁获取锁的方式如下
final void lock() { acquire(1); } public final void acquire(int arg) { //tryAcquire:尝试去获取锁 //addWaiter:线程入队，一个同步等待队列，基于双向列表实现 //链表中的每一个结点为一个Node结点， if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); } //线程入队操作 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; } //判断是否获取锁 protected final boolean tryAcquire(int acquires) { //获取当前获取锁的线程 final Thread current = Thread.currentThread(); //获取当前同步器状态，被volatile修饰的整型值，默认为0 int c = getState(); //如果同步状态器的值为0，说明外面的线程可以进行加锁操作 if (c == 0) { //hasQueuedPredecessors:判断队列中是否还有在排队的节点 //compareAndSetState:原子操作，比较与交换，进行加锁的操作，将state变量将0变为1 //setExclusiveOwnerThread:设置获取锁的的线程拥有者 if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } //如果状态同步器不为0，可能由自己持有，也可能由别的线程持有锁 //重复加锁，如定义一个全局锁，出现了这个可重入锁的问题 else if (current == getExclusiveOwnerThread()) { //如果自己持有锁的话，state+1即可，反正不等于0就可以 int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } //别的线程获有锁，直接返回 return false; }
总而言之就是说，公平锁就是就是通过一个队列实现，需要进行排队的去获取锁资源。主要是通过这个state的资源状态器来控制获取锁的拥有者，如果state为0，则表示队列中的下一个线程可以去获取锁，并且通过cas的方式来保证锁的安全并发问题。通过队列的思想，来保证这个获取锁的公平性和有序性。
3.2，NofairSync
实现了非公平锁，默认为非公平锁，会存在抢锁的情况
ReentrantLock reentrantLock = new ReentrantLock(flase); //如果不传入参数，默认是非公平锁 public ReentrantLock() { sync = new NonfairSync(); } public ReentrantLock(boolean fair) { //入参，用于判断是公平锁还是非公平锁 sync = fair ? new FairSync() : new NonfairSync(); } //非公平锁的实现 static final class NonfairSync extends ReentrantLock.Sync{...}
非公平锁获取锁的方法和公平锁类似，只是少了几步使用队列的几个方法
3.3，AQS中几个重要的相关参数
exclusiveOwnerThread：用于记录当前独占模式下，获取锁的线程是谁
state：同步状态器，默认为0，表示当前没有线程获取锁，外面的线程可以来获取锁了
Node：双向链表结构，是一个同步等待队列，head：队头，tail：队尾，prev前躯指针，next，后继指针
waiteState：结点的什生命状态
Lock锁和synchronized锁都是可重入锁
3.4，Node
pre：前驱指针
next：后继指针
waitStatues：每个结点都存在很多状态，这个主要是存储结点的生命状态
结点的几个生命状态如下
SIGNAL:-1 //可被唤醒 CANCELLED:1 //代表异常，中断引起的，需要被废弃 CONDITION:-2 //条件等待 PROPAGATE:-3 //传播 Init:0初始状态
结点入队顺序如下,入队时，将入队结点得前驱指针指向链表的tail结点，将tail节点的next节点指向当前节点，并将当前结点设置为tail尾指针结点。
private Node enq(final Node node) { //自旋 for (;;) { Node t = tail; if (t == null) { // Must initialize //如果队列为空，要防止出现多个线程的并发问题，结点直接放在队头 if (compareAndSetHead(new Node())) tail = head; } else { node.prev = t; //保证这个入队的安全性，防止入队出现并发问题 //结点入队到队尾 if (compareAndSetTail(t, node)) { t.next = node; return t; } } } }
当前结点前面有结点获取锁，当前节点需要进行阻塞park，线程要开始排队等待。
结点在阻塞之前，还得尝试获取一次锁。
a，如果结点可以获取到锁，即当前节点为头结点的下一个结点，头结点即将锁被释放，则把当前结点作为头结点。之前的头结点就可以被GC回收了
b，如果结点不能获取到锁，那么当前结点就要等待被唤醒
(1),第一轮循环会去修改head状态，并且将waitState修改为sinal = -1可被唤醒状态
(2),第二轮，阻塞线程
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); } }
每个结点的生命状态的变换如下。默认的结点状态为0，需要将节点状态(waitState)转化为-1可唤醒状态。前一个节点中的waitStatus状态记录着后一个节点的生命状态。
//pred:前驱节点 node:当前节点 private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { //默认为初始状态0 int ws = pred.waitStatus; //SIGNAL为-1，可被唤醒状态 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); } return false; }
在修改成可被唤醒的状态之后，就进行阻塞操作。
private final boolean parkAndCheckInterrupt() { //阻塞线程，并且判断该线程是否是被中断的 LockSupport.park(this); return Thread.interrupted(); }
在头结点释放锁的时候，也会发一个通知去告知下一个需要获取锁的线程来抢锁，即唤醒队列中的下一个被阻塞的线程
//真正的释放锁 public void unlock() { sync.release(1); } public final boolean release(int arg) { //尝试释放锁 if (tryRelease(arg)) { Node h = head; //因为前一个结点中存放后一个节点中的声明状态，因此 //如果头结点的waitStatus不为0，就说明后一个结点是一个可被唤醒的状态 if (h != null && h.waitStatus != 0) //唤醒 unparkSuccessor(h); return true; } return false; } //尝试去释放锁 protected final boolean tryRelease(int releases) { //修改同步状态器state int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); boolean free = false; //将同步状态器state 变为 0，说明当前同步状态器可以进行锁的获取了 if (c == 0) { free = true; //置空当前线程 setExclusiveOwnerThread(null); } setState(c); return free; }
最后在这个unparkSuccessor方法中，也有这个具体的unpark唤醒操作
if (s != null) LockSupport.unpark(s.thread)
通过上述代码描述，也验证了一开始的猜想：自旋，加锁，LockSupport，队列(LinkQueue)
