public class 读写锁的策略 {
    public static void main(String[] args) {
        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock readLock = readWriteLock.readLock();
        ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();
        //
        readLock.lock();
        readLock.unlock();
        writeLock.lock();
        writeLock.unlock();
    }
}

3.重量级锁&轻量级锁

解释

锁的核心特性 "原子性", 这样的机制追根溯源是 CPU 这样的硬件设备提供的.

CPU 提供了 "原子操作指令".
操作系统基于 CPU 的原子指令, 实现了 mutex 互斥锁.
JVM 基于操作系统提供的互斥锁, 实现了 synchronized 和 ReentrantLock 等关键字和类

尽量不使用重量级锁，但是如果线程冲突严重的话还是会使用重量级锁（主要区别涉及用户态和内核态的切换）

4.自旋锁

实际上是Java层面无锁的操作
以自旋的方式，执行乐观锁修改数据的操作
会反复来进行尝试修改数据（不修改成功不退出）
自旋锁一般都结合乐观锁来进行使用

5.公平锁&非公平锁

公平锁与非公平锁的机制，就类似于，先来先服务，这是公平的，所有线程同时竞争，不讲究顺序，这就是不公平的
不公平锁可能会引发饥饿现象

6.可重入锁&不可重入锁

可重入锁的字面意思是“可以重新进入的锁”，即允许同一个线程多次获取同一把锁。
比如一个递归函数里有加锁操作，递归过程中这个锁会阻塞自己吗？如果不会，那么这个锁就是可重入锁（因为这个原因可重入锁也叫做递归锁）。
Java里只要以Reentrant开头命名的锁都是可重入锁，而且JDK提供的所有现成的Lock实现类，包括synchronized关键字锁都是可重入的。
而 Linux 系统提供的 mutex 是不可重入锁.

7.独占锁&共享锁

同一个时间只有一个线程能获取到锁，就是独占锁
同一个时间，可以有多个线程同时获取到锁，就是共享锁

五，synchronized拓展（补充）

1.作用

基于对象头加锁的方式，实现同步互斥

字段：状态

状态的值：（锁可以升级，但是不能降级）

无锁：没有任何线程申请到该对象的锁

偏向锁：第一次进入的线程，或是这个线程再次申请到同一个对象锁

轻量级锁：出现线程冲突，但冲突概率比较小（cas+自旋锁）

重量级锁：线程冲突比较严重，真实的进行加锁（使用操作系统mutex加锁）

2.原理

3.jvm对synchronized的优化

1）锁消除

锁消除就是字面意思，直接将锁去掉不使用锁，但是前提就是只有一个线程可以操作

2）锁粗化

举个简单的栗子：老师给学生打电话布置课堂作业，打电话，布置作业1，2，3，挂断电话

原始情况其实应该是：打电话，布置任务1，挂电话

打电话，布置任务2，挂电话

打电话，布置任务3，挂电话

前提条件：同一个线程调用，但是这个变量是所有线程都可以获取到的

4.synchronized和lock可以实现的锁策略

六，CAS

1.什么是cas

CompareAndSwap 比较并交换
是jdk提供的一种乐观锁的实现，能够满足线程安全的条件，并且以乐观锁的方式来修改变量

1）比较从主存读与写回主存时是否相等。（比较）
2）如果比较相等，将工作内存中修改的值写入主存。（交换）
3）返回操作的结果

2.jdk是如何提供cas的？/cas的原理？

1）jdk提供了一个unsafe的类，来执行cas的操作

2）jdk中unsafe提供的cas方法，又是基于操作系统提供的cas方法

简单点说就是，unsafe时基于操作系统和cpu提供的cas来实现的

3.CAS的应用

比较常见的，java.util.concurrent.atomic包下都是使用了cas来保证线程安全的，如：++，--，!flag

4.CAS可能存在的问题，ABA问题

ABA 的问题:
假设存在两个线程 t1 和 t2. 有一个共享变量 num, 初始值为 A.
接下来, 线程 t1 想使用 CAS 把 num 值改成 Z, 那么就需要

先读取 num 的值, 记录到 oldNum 变量中.

使用 CAS 判定当前 num 的值是否为 A, 如果为 A, 就修改成 Z.

但是, 在 t1 执行这两个操作之间, t2 线程可能把 num 的值从 A 改成了 B, 又从 B 改成了 A

举个例子：

5.解决ABA问题

给要修改的值, 引入版本号. 在 CAS 比较数据当前值和旧值的同时, 也要比较版本号是否符合预期.

CAS 操作在读取旧值的同时, 也要读取版本号.
真正修改的时候,
如果当前版本号和读到的版本号相同, 则修改数据, 并把版本号 + 1.
如果当前版本号高于读到的版本号. 就操作失败(认为数据已经被修改过了).

6.CAS总结

1）什么叫cas

比较并交换
比较从主存读与写回主存时是否相等
如果相等就交换

2）原理

属于乐观锁的一种
jdk提供了一个叫unsafe的类，来实现cas的操作
unsafe又是基于操作系统和cpu的cas来实现的

3）应用

atomic包下的类

4）存在的问题

ABA问题
解决方法：引入版本号，jdk提供了一个叫AtomicStampedReference类来管理版本号

多线程（基础2）

一，线程通信

1）wait()&notify()

2）作用

3）实现

4）wait() 和 sleep() 的区别

二，阻塞队列

1）概念

2）生产者消费者模型

3）标准库中的阻塞队列

三，线程池

为什么要创建线程池

作用

为什么不能使用快捷创建的方式

理解 ThreadPoolExecutor 构造方法的参数

线程池的工作流程

四，常见的锁策略

1.乐观锁&悲观锁

1）悲观锁的概念

2）乐观锁的概念

3）乐观锁的实现

2.读写锁

使用场景

实例