上次主要说的就是锁，锁的应用，梳理了锁的原理，其实你会发现，没有太多技巧性的内容点，这个不容易看明白，先明白原理在看代码。这个更方便理解。学习的过程就是：采坑，入坑，回头看看风景不错。本次主要围绕JUC开发，里面有很多类。
（一）Lock的核心API
- ① 介绍
LOCK也提供同步的特性，但是为什么必须使用锁，想比较同步而言，它的灵活性更加高，提供了一系列的API。同步关键字synchronized，要么是执行完，如果没执行完的话需要一直等待。Lock类里面有个trylock() ，就是试一下，如果拿到拿不到锁，就立刻返回，还可以设置等待时间，lock.tryLock(10000L, TimeUnit.MILLISECONDS)。使用它的主要原因，就是灵活。并不是因为性能高。
- ② 常用方法
1.lock
获取锁的方法，若锁被其他线程获取，则等待（阻塞）
2.lockInterruptbly
在锁的获取过程中可以中断当前线程
3.tryLock
尝试非阻塞地获取锁，立即返回
4.unlock
释放锁
- ③ 代码演示
import java.util.concurrent.locks.ReentrantLock;
// 演示可重入
public class ReentrantDemo1 {
private static final ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
lock.lock(); // block until condition holds
try {
System.out.println("第一次获取锁");
System.out.println("当前线程获取锁的次数" + lock.getHoldCount());
lock.lock();
System.out.println("第二次获取锁了");
System.out.println("当前线程获取锁的次数" + lock.getHoldCount());
} finally {
lock.unlock();
lock.unlock();
}
System.out.println("当前线程获取锁的次数" + lock.getHoldCount());
// 如果不释放，此时其他线程是拿不到锁的
new Thread(() -> {
System.out.println(Thread.currentThread() + " 期望抢到锁");
lock.lock();
System.out.println(Thread.currentThread() + " 线程拿到了锁");
}).start();
}
}
第一个线程拿到锁，第二个线程执行要做的下面的事情，如果第一个线程不释放锁的话，其他线程是拿不到锁的，可重入就是同一把锁被锁了多次，都释放后这个锁就没被使用了，可重入是之同一个线程的意思。
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
// 可响应中断
public class LockInterruptiblyDemo1 {
private Lock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
LockInterruptiblyDemo1 demo1 = new LockInterruptiblyDemo1();
Runnable runnable = new Runnable() {
@Override
public void run() {
try {
demo1.test(Thread.currentThread());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
Thread thread1 = new Thread(runnable);
Thread thread2 = new Thread(runnable);
thread1.start();
Thread.sleep(500); // 等待0.5秒，让thread1先执行
thread2.start();
Thread.sleep(2000); // 两秒后，中断thread2
thread2.interrupt();
}
public void test(Thread thread) throws InterruptedException {
System.out.println(Thread.currentThread().getName() + "， 想获取锁");
lock.lockInterruptibly(); //注意，如果需要正确中断等待锁的线程，必须将获取锁放在外面，然后将InterruptedException抛出
try {
System.out.println(thread.getName() + "得到了锁");
Thread.sleep(10000); // 抢到锁，10秒不释放
} finally {
System.out.println(Thread.currentThread().getName() + "执行finally");
lock.unlock();
System.out.println(thread.getName() + "释放了锁");
}
}
}
响应中断的lockInterruptibly，就是响应了不继续等待。
（二） 读写锁的实现
- ① 介绍
维护一对关联锁，一个用于只读操作，一个用于写入，读锁可以由多个读线程同时持有，写锁是排他的。适合读取线程比写入线程多的场景，改进互斥锁的性能。
- ② 场景
缓存组件，集合的并发线程安全性改造。
- ③ 示例
不用读写锁
public class ReentrantReadWriteLockDemo1 {
public static void main(String[] args) {
final ReentrantReadWriteLockDemo1 readWriteLockDemo1 = new ReentrantReadWriteLockDemo1();
// 多线程同时读/写
new Thread(() -> {
readWriteLockDemo1.read(Thread.currentThread());
}).start();
new Thread(() -> {
readWriteLockDemo1.write(Thread.currentThread());
}).start();
new Thread(() -> {
readWriteLockDemo1.read(Thread.currentThread());
}).start();
}
// 不管读写，只有一个线程能用， 独享锁
public synchronized void read(Thread thread) { // 2秒
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName()+"正在进行“读”操作");
}
System.out.println(thread.getName()+"“读”操作完毕");
}
/** 写 */
public synchronized void write(Thread thread) {
long start = System.currentTimeMillis();
while(System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName()+"正在进行“写”操作");
}
System.out.println(thread.getName()+"“写”操作完毕");
}
}
通过同步代码块来完成， 独占的话，性能问题，原本修改数据加锁还算可以，但是读数据你也加锁，就说不过去了，线程1-2 就是读数据。一般都是读多写少，为了偶然的一次写导致加锁性能消耗这是不应该的。
读写锁（既保证了读数据的效率，也保证数据的一致性），一个读锁，一个写锁。
看了这个图 应该基本明白了吧
import java.util.concurrent.locks.ReentrantReadWriteLock;
// 读写锁（既保证了读数据的效率，也保证数据的一致性）
public class ReentrantReadWriteLockDemo2 {
ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public static void main(String[] args) {
final ReentrantReadWriteLockDemo2 readWriteLockDemo2 = new ReentrantReadWriteLockDemo2();
// 多线程同时读/写
new Thread(() -> {
readWriteLockDemo2.read(Thread.currentThread());
}).start();
new Thread(() -> {
readWriteLockDemo2.read(Thread.currentThread());
}).start();
new Thread(() -> {
readWriteLockDemo2.write(Thread.currentThread());
}).start();
}
// 多线程读，共享锁
public void read(Thread thread) {
readWriteLock.readLock().lock();
try {
long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName() + "正在进行“读”操作");
}
System.out.println(thread.getName() + "“读”操作完毕");
} finally {
readWriteLock.readLock().unlock();
}
}
/**
* 写
*/
public void write(Thread thread) {
readWriteLock.writeLock().lock();
try {
long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start <= 1) {
System.out.println(thread.getName() + "正在进行“写”操作");
}
System.out.println(thread.getName() + "“写”操作完毕");
} finally {
readWriteLock.writeLock().unlock();
}
}
}
提供了writeLock 和 readLock ，一个读锁一个写锁，读锁可以共享的。写锁是独立的。当读锁在被多个线程调用的时候，写锁不允许写入数据。
- ④ 锁降级
锁降级 ： 是指保持住当前的写锁（已拥有），再获取读锁，随后释放写锁的过程。
首先写锁是独占的，读锁是共享的，然后读写锁是线程间互斥的，锁降级的前提是所有线程都希望对数据变化敏感，但是因为写锁只有一个，所以会发生降级。
如果先释放写锁，再获取读锁，可能在获取之前，会有其他线程获取到写锁，阻塞读锁的获取，就无法感知数据变化了。所以需要先hold住写锁，保证数据无变化，获取读锁，然后再释放写锁。 写可以到读是降级，读不可以到写
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
// 缓存示例
public class CacheDataDemo {
// 创建一个map用于缓存
private Map<String, Object> map = new HashMap<>();
private static ReadWriteLock rwl = new ReentrantReadWriteLock();
public static void main(String[] args) {
// 1 读取缓存里面的数据
// cache.query()
// 2 如果换成没数据,则取数据库里面查询 database.query()
// 3 查询完成之后,数据塞到塞到缓存里面 cache.put(data)
}
public Object get(String id) {
Object value = null;
// 首先开启读锁，从缓存中去取
rwl.readLock().lock();
try {
if (map.get(id) == null) {
// TODO database.query(); 全部查询数据库 ,缓存雪崩
// 必须释放读锁
rwl.readLock().unlock();
// 如果缓存中没有释放读锁，上写锁。如果不加锁，所有请求全部去查询数据库，就崩溃了
rwl.writeLock().lock(); // 所有线程在此处等待 1000 1 999 (在同步代码里面再次检查是否缓存)
try {
// 双重检查，防止已经有线程改变了当前的值，从而出现重复处理的情况
if (map.get(id) == null) {
// TODO value = ...如果缓存没有，就去数据库里面读取
}
rwl.readLock().lock(); // 加读锁降级写锁,这样就不会有其他线程能够改这个值，保证了数据一致性
} finally {
rwl.writeLock().unlock(); // 释放写锁@
}
}
} finally {
rwl.readLock().unlock();
}
return value;
}
}
（三）同步锁的本质-排队
1.同步的方式
独享锁-单个队列窗口，共享锁-多个队列窗口
2.强锁的方式
插队抢（不公平锁），先来后到抢锁（公平锁）
3.没抢到锁的处理方式
快速尝试多次（CAS自旋锁）阻塞等待
- 唤醒阻塞线程的方式（叫号器）
全部通知，通知下一个
（四）AQS抽象队列同步器
- ① 介绍
对资源占用，释放，线程的等待，唤醒等等接口和具体实现
AQS是AbustactQueuedSynchronizer的简称，它是一个Java提供的底层同步工具类，用一个int类型的变量表示同步状态，并提供了一系列的CAS操作来管理这个同步状态。AQS的主要作用是为Java中的并发同步组件提供统一的底层支持，例如ReentrantLock，CountdowLatch就是基于AQS实现的，用法是通过继承AQS实现其模版方法，然后将子类作为同步组件的内部类。
- ② AQS可重写的方法
- ③ 在实现同步组件时AQS提供的模板方法
- ④ AQS提供的模板方法
- 独占式获取与释放同步状态。
- 共享式获取与释放同步状态。
- 查询同步队列中等待线程情况。
同步组件通过AQS提供的模板方法实现自己的同步语义。
- ⑤ 八个方法
1.acquire，acquireShared
定义了资源争用的逻辑，如果没拿到，则等待。
2.tryAcquire，tryAcquireShared
实际直行占用资源的操作，如何判定一个由使用者具体去实现。
3.release，releaseShared
释放资源的逻辑，释放之后，通知后续节点进行争抢。
4.tryRelease，tryReleaseShared
实际执行资源释放的操作，具体的AQS使用者来实现。
PS：AQS提供了三大功能：独占锁、共享锁、ConditionObject。子类在实现中，可以实现其一部分方法。其编程思想值得借鉴，通过超类实现基本的处理流程，将其中部分抽成未实现方法，默认抛出异常，由子类实现，这种解耦方式，最大化的减少了代码的重复，且便于子类在实现中个性化自己的处理逻辑。
