Java基础之《AQS》

一、谈谈Lock锁底层实现原理
1、底层基于AQS+CAS+LockSupport锁实现

二、synchronized与lock锁之间区别
1、Lock锁基于AQS封装的锁，结合CAS实现，而Lock锁的升级过程需要自己实现，Lock锁是Java实现的
2、synchronized是基于C++虚拟机封装，从JDK1.6开始，JDK可以帮你实现锁的升级过程
3、锁的升级过程（轻量级锁、偏向锁、重量级锁）
synchronized锁由C语言帮你实现好了，Lock锁需要自己实现
4、JDK1.8里像ConcurrentHashMap、HashTable集合，用的都是synchronized锁，很少使用Lock锁，所以建议用synchronized锁（JDK1.7里，ConcurrentHashMap使用Lock锁，自己实现锁的升级过程）

三、谈谈LockSupport的用法

	public static void main(String[] args) {
		Thread t1 = new Thread(new Runnable() {
			
			@Override
			public void run() {
				System.out.println(Thread.currentThread().getName() + "start");
				//当前线程阻塞
				LockSupport.park();
				System.out.println(Thread.currentThread().getName() + "end");
			}
		});
		t1.start();
		
		try {
			//主线程等待3秒
			Thread.sleep(3000);
		} catch (Exception e) {
			
		}
		//唤醒阻塞线程
		LockSupport.unpark(t1);
	}

执行结果：
先打印Thread-0start
LockSupport.park();阻塞当前线程
主线程等待3秒
LockSupport.unpark(t1);唤醒阻塞线程
打印Thread-0end

四、查看Lock锁的源码

	public static void main(String[] args) {
		ReentrantLock lock = new ReentrantLock(); //可重入锁
		lock.lock();
		lock.unlock();
	}

1、lock.lock();调用
2、请求锁

public void lock() {
        sync.lock();
    }

3、Sync对象继承自AQS类

abstract static class Sync extends AbstractQueuedSynchronizer {
...
}

4、Sync对象有两个子类

FairSync ---公平锁
NonfairSync ---非公平锁
父类都是AbstractQueuedSynchronizer
5、公平锁和非公平锁
非公平锁：靠抢，会有一个线程拿到一把锁多次，而其它线程拿不到锁

公平锁：用一个队列排队
线程A先获取锁，线程A用完交给线程B，线程A放到链表的后面
6、怎么知道锁是公平还是非公平
看构造函数

public ReentrantLock() {
        sync = new NonfairSync();
    }

 默认情况下，Lock锁是非公平锁
7、看非公平锁的lock方法实现

final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

做了CAS的操作，如果成功的情况下，设置当前哪个线程获取锁。如果没有成功走到重试
8、重试的方法

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

如果重试多次还不行，会把我们当前线程阻塞，放到链表中

五、AQS底层实现原理
1、首先有个状态值，为：0、1、>1
状态等于0：当前我们锁没有被任何线程持有
状态等于1：锁已经被其他线程持有
大于1：是当前线程重入
2、有一个没有获取到锁的线程集合
在AQS里是用双向链表去实现的
3、图解

1）有T1、T2、T3，三个线程
2）T1抢到锁，T2、T3阻塞放入线程队列
3）T1执行完代码后，释放锁，唤醒阻塞的线程
4）非公平锁的情况下，T1、T2、T3继续争抢锁
4、线程重入的情况

A() {
    Lock.lock(); //状态=1
    ...
    B() {
        Lock.lock(); //状态=2
           ...
        C() {
            Lock.lock(); //状态=3
            ...
            Lock.unlock();
        }
        Lock.unlock();
    }
    Lock.unlock();
}

A方法调B方法，B方法调C方法。获取Lock锁有3次

六、AQS核心参数有哪些
1、Node节点
采用双向链表的形式存放正在等待的线程：
Node节点包含，waitStatus状态、thread等待锁的线程
2、waitStatus状态解释
CANCELLED，值为1，表示当前的线程被取消
SIGNAL，值为-1，释放资源后需唤醒后续节点
CONDITION，值为-2，等待condition唤醒
PROPAGATE，值为-3，工作于共享锁状态，需要向后传播，比如根据资源是否剩余，唤醒后续节点
值为0，表示当前节点在sync队列中，等待着获取锁
3、等待队列
1）head头节点：等待队列的头节点
2）tail尾节点：正在等待的线程
3）state锁的状态：0无锁、1已获取锁，当前线程重入不断+1
4）exclusiveOwnerThread记录锁的持有
4、核心方法
//重试获取锁，如果小于0的情况则当前线程会追加到链表中
1）tryAcquireShared(arg)
//如果为true的情况下，则开始唤醒阻塞的线程
2）tryReleaseShared(arg)

参考资料：
https://blog.csdn.net/a18792721831/article/details/106730738
https://segmentfault.com/a/1190000023315634