1.悲观锁 ：锁住资源其他线程不能在访问

2.乐观锁： 不锁资源，默认其他进程不会修改资源 

锁住同步资源失败 线程是否需要阻塞？

阻塞

不阻塞： 自旋锁  适应性自旋锁      减少了线程上下文的其二环   因为是不阻塞 而是一直原地等待  

多线程竞争同步资源的流程细节有没有区别

1.不锁住资源  多个线程中只有一个能修改资源，其他线程重试   

2.同意下城执行同步资源时自动获取资源    偏向锁

3.多个线程竞争同步资源时，没有获取资源的线程自旋等待锁释放   轻量级锁

4.多个线程竞争同步资源时 没有获取资源的线程线程阻塞等待唤醒  重量级锁

自旋锁和自适应自旋锁

AQS同步器   Abstrac Queue Sych

ReentranLock 

公平锁和非公平锁

排队公平 

非公平 插队 如果失败再按公平走 

非公平吞吐量要大得多

可重入锁 加多次锁

们把使用Lock接口实现线程同步的锁称之为 显示锁，使用synchronized的称为 隐式锁 或 java内置锁

LockSupport 挂起和唤醒线程

void park()   阻塞当前线程

void  unpark()  获取 许可证

被阻塞的线程可以通过  interrupt 方法来唤醒

void parkNanos 

 该方法的不同在于 ，如果
没有拿到许可证，则调用线程会被挂起 nanos 时间后修改为自动返回。
 

（1）wait和notify都是Object中的方法,在调用这两个方法前必须先获得锁对象，但是park不需要获取某个对象的锁就可以锁住线程。

（2）notify只能随机选择一个线程唤醒，无法唤醒指定的线程，unpark却可以唤醒一个指定的线程。

阻塞 

wait notify    让出资源锁  非公平锁  下一个获得的线程  粗颗粒
lockspoout  park  unpark  不让资源锁 即不可被重用
 

锁

synchronized

lock unlock  直接锁

condition.await singleall    让出资源   也是使用了 

LockSupport 类  park 和  unpark 方法

锁的底层支持  AQS  抽象同步队列

AbstractQueuedSynchronizer

AQS 是一个 FIFO 的双向队列，其内部通过节点 head 和 tail 记录队首和队尾元素    队列元素的类型为 Node 其中 Node 中的 thread 变量用来存放进入 AQS队列里面的线程：

ode 节点内部的 SHARED 用来标记该线程是获取共享资源时被阻塞
挂起后放入 AQS 队列的， EXCLUSIVE 用来标记线程是获取独占资源时被挂起后放入
AQS 队列的 ； waitStatus 记录当前线程等待状态，可以为 CANCELLED （线程被取消了）、
SIGNAL （ 线程需要被唤醒）、 CONDITION （线程在条件队列里面等待〉、 PROPAGATE （释
放共享资源时需要通知其他节点〕； prev 记录当前节点的前驱节点， next 记录当前节点的
后继节点 。

在 AQS 中 维持了 一 个 单 一 的状态信息 state，可以通过 getState 、 setState 、
compareAndS etState 函数修改其值 。 对于 Reentran tLock 的 实 现来说， state 可以用 来表示
当 前线程获取锁的可重入次数 ；对于 读写锁 ReentrantReadWriteLock 来说 ， state 的 高 16
位表示读状态，也就是获取该读锁的次数，低 16 位表示获取到写锁的线程的可重入次数；
对于 semaphore 来说， state 用来表示当前可用信号的 个数：对于 CountDownlatch 来说，
state 用 来表示计数器当前的值 。

assert 关键字 表示断言，

  

ReetrantLock 是一种独占式的可重入锁  就是可以多次 加锁 释放锁  他是通过内部一个status状态量来进行处理的  悲观锁

然后他其实真正实现的是一个sycn的内部类 实现了AQS这个抽象类，那个状态量 其实也是AQS的   state   是一个用volatile 修饰的私有变量

然后实现了AQS里面的一些方法  包括加锁去锁啊 判断是否有锁  等一些方法  

还有一个比较特别的就是  他可以设置条件变量锁，就是那个condition 锁 ，然后可以通过await方法和single方法来实现线程的阻塞和唤醒

然后他有公平和非公平两种创建。

公平就是按顺序先来后到   非公平就是可以插队

通过理解实现一个线程安全list  理解  volatile和ReetrantLock  的使用

volatile的共享和RL 的原子性

并发包 源码解读

内存操作  对象内存

Unsafe unsafe = Unsafe.getUnsafe();

unsafe.objectFieldOffset
    (AtomicInteger.class.getDeclaredField("value"));

使用了大量CAS操作  比较并交换

1.AtomicBoolean

2.AtomicIntger

3.AtomicLong

java锁机制

1. 乐观锁 VS 悲观锁

​ 悲观锁认为自己在使用数据的时候一定有别的线程来修改数据，因此在获取数据的时候会先加锁，确保数据不会被别的线程修改。Java中，synchronized关键字和Lock的实现类都是悲观锁。

​ 乐观锁认为自己在使用数据时不会有别的线程修改数据，所以不会添加锁，只是在更新数据的时候去判断之前有没有别的线程更新了这个数据。如果这个数据没有被更新，当前线程将自己修改的数据成功写入。如果数据已经被其他线程更新，则根据不同的实现方式执行不同的操作（例如报错或者自动重试）

​ 乐观锁在Java中是通过使用无锁编程来实现，最常采用的是CAS算法，Java原子类中的递增操作就通过CAS自旋实现的。

根据从上面的概念描述我们可以发现：

• 悲观锁适合写操作多的场景，先加锁可以保证写操作时数据正确。
• 乐观锁适合读操作多的场景，不加锁的特点能够使其读操作的性能大幅提升。

​ CAS全称 Compare And Swap（比较与交换），是一种无锁算法。在不使用锁（没有线程被阻塞）的情况下实现多线程之间的变量同步。java.util.concurrent包中的原子类就是通过CAS来实现了乐观锁。

CAS算法实现思想

CAS算法涉及到三个操作数：

• 需要读写的内存值 V。
• 进行比较的值 A。
• 要写入的新值 B。

当且仅当 V 的值等于 A 时，CAS通过原子方式用新值B来更新V的值（“比较+更新”整体是一个原子操作），否则不会执行任何操作。一般情况下，“更新”是一个不断重试的操作。

举例：

在线程开启的时候，会从主存中给每个线程拷贝一个变量副本到线程各自的运行环境中，CAS算法中包含三个参数(V,E,N)，V表示要更新的变量(也就是从主存中拷贝过来的值)、E表示预期的值、N表示新值。

实现过程

CAS算法中包含三个参数(V,E,N)，V表示要更新的变量(也就是从主存中拷贝过来的值)、E表示预期的值、N表示要写回内存的新值。

假设现在有两个线程t1,t2,他们各自的运行环境都有共享变量的副本V1,V1,预期值E1,E2，现在主存里面数据一直没有被改变，所以创建的两个变量里面的E都还是20，假设并行开发环境中t1先拿到了执行权（即先对V进行操作），先从主存那拿到V的值，V1=V,比较预期值E1和主存的值V1，若E1=V1，说明预期值正确，N1=V1+1;并将N1的值传回去主存。此时主存中V=21，然后t2拿到了执行权,先从主存那拿到V的值，V2=V,，t2比较E2与V2,E2!=V2,t2将主存的值更新到自己的工作内存中，E2=V2=21,再发起重试，直到E2=V2,说明此时没有别的线程对旧值进行修改，进行执行N2=V2+1,并将N2的值传回去主存，然后退出。

相当于do{}while()循环，直到E=V才写入内存，退出循环

java.util.concurrent包中的原子类，就是通过CAS来实现了乐观锁，比如说原子类AtomicInteger,AtomicInteger源码讲解在下方链接

CAS锁ABA问题，通过在值前面加上版本号

AtomicInteger中调用unsafe进行自增操作的源码中的do-while循环，就是自旋锁

java中的各种锁详细介绍 - JYRoy - 博客园 (cnblogs.com)

2.自旋锁 VS 适应性自旋锁

阻塞或唤醒一个Java线程需要操作系统切换CPU状态来完成，这种状态转换需要耗费处理器时间。如果同步代码块中的内容过于简单，状态转换消耗的时间有可能比用户代码执行的时间还要长。

在许多场景中，同步资源的锁定时间很短，为了这一小段时间去切换线程，线程挂起和恢复现场的花费可能会让系统得不偿失。如果物理机器有多个处理器，能够让两个或以上的线程同时并行执行，我们就可以让后面那个请求锁的线程不放弃CPU的执行时间，看看持有锁的线程是否很快就会释放锁。

而为了让当前线程“稍等一下”，我们需让当前线程进行自旋，如果在自旋完成后前面锁定同步资源的线程已经释放了锁，那么当前线程就可以不必阻塞而是直接获取同步资源，从而避免切换线程的开销。这就是自旋锁。

java中的各种锁详细介绍 - JYRoy - 博客园 (cnblogs.com)

自旋等待的时间必须要有一定的限度，如果自旋超过了限定次数（默认是10次，可以使用-XX:PreBlockSpin来更改）没有成功获得锁，就应当挂起线程。

自旋锁的实现原理同样也是CAS，AtomicInteger中调用unsafe进行自增操作的源码中的do-while循环就是一个自旋操作，如果修改数值失败则通过循环来执行自旋，直至修改成功。

非自旋锁直接堵塞，线程休眠直到锁被释放，恢复现场，再次尝试获取锁

3.无锁 VS 偏向锁 VS 轻量级锁 VS 重量级锁

锁的不同状态来着

4. 公平锁 VS 非公平锁

公平锁是指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。公平锁的优点是等待锁的线程不会饿死。缺点是整体吞吐效率相对非公平锁要低，等待队列中除第一个线程以外的所有线程都会阻塞，CPU唤醒阻塞线程的开销比非公平锁大。

非公平锁是多个线程加锁时直接尝试获取锁，获取不到才会到等待队列的队尾等待。但如果此时锁刚好可用，那么这个线程可以无需阻塞直接获取到锁，所以非公平锁有可能出现后申请锁的线程先获取锁的场景。非公平锁的优点是可以减少唤起线程的开销，整体的吞吐效率高，因为线程有几率不阻塞直接获得锁，CPU不必唤醒所有线程。缺点是处于等待队列中的线程可能会饿死，或者等很久才会获得锁。

5. 可重入锁 VS 非可重入锁

可重入锁又名递归锁，是指在同一个线程在外层方法获取锁的时候，再进入的、内层方法会自动获取锁（前提锁对象得是同一个对象或者class），不会因为之前已经获取过还没释放而阻塞。Java中ReentrantLock和synchronized都是可重入锁，可重入锁的一个优点是可一定程度避免死锁。

6. 独享锁 VS 共享锁

独享锁和共享锁同样是一种概念。我们先介绍一下具体的概念，然后通过ReentrantLock和ReentrantReadWriteLock的源码来介绍独享锁和共享锁。

独享锁也叫排他锁，是指该锁一次只能被一个线程所持有。如果线程T对数据A加上排它锁后，则其他线程不能再对A加任何类型的锁。获得排它锁的线程即能读数据又能修改数据。JDK中的synchronized和JUC中Lock的实现类就是互斥锁。

共享锁是指该锁可被多个线程所持有。如果线程T对数据A加上共享锁后，则其他线程只能对A再加共享锁，不能加排它锁。获得共享锁的线程只能读数据，不能修改数据。

从java的视角看synchronized synchronized使用的锁对象(monitor)存储在java对象头中。

java中的各种锁详细介绍 - JYRoy - 博客园 (cnblogs.com)

(52条消息) sychornized_学习仪式感的博客-CSDN博客

(52条消息) 深入理解Java并发之synchronized实现原理_zejian的博客-CSDN博客_synchronized底层原理

Java并发编程：Lock - Matrix海子 - 博客园 (cnblogs.com)