java本地锁与分布式锁-个人笔记 @by

java本地锁与分布式锁-个人笔记 @by_TWJ

1. 本地锁
- 1.1. 悲观锁与乐观锁
- 1.2. 公平锁与非公平锁
- 1.3. CAS
- 1.4. synchronized
- 1.5. volatile 可见性
- 1.6. ReentrantLock 可重入锁
- 1.7. AQS
- 1.8. ReentrantReadWriteLock 可重入读写锁
2. 分布式锁
3. 额外的
- 3.1. synchronized 的锁升级原理
- 3.2. synchronized锁原理

1. 本地锁

1.1. 悲观锁与乐观锁

是一种思想，按遇到并发问题概率的思考，分为：乐观锁（很少发生并发问题）、悲观锁（一定会发生并发问题）

乐观锁的实现有 CAS
悲观锁的实现有 synchronized、lock等

1.2. 公平锁与非公平锁

按获取锁的顺序，分为：公平锁（按顺序获取锁）、非公平锁（看谁唤醒快，谁就抢到锁）

1.3. CAS

CAS 即比较与保存，底层使用的是一种自旋锁。

CAS存在ABA问题，解决办法，添加版本标识。

CAS常见的实现类有：
AtomicBoolean、AtomicInteger、AtomicLong、AtomicReference 等等。

1.4. synchronized

synchronized 是一种同步锁，可以锁方法与锁代码块（锁对象）。

根据锁的并发程度不同，升级锁（不可降级），分为三个状态：偏向锁、轻量级锁、重量级锁。

偏向锁 - 无多线程下，拿锁不需要竞争。在对象Mark Word中记录偏向线程ID。
轻量级锁 - 多线程下，拿不到锁，就会进入轻量级锁。使用CAS方式自旋获取锁。
重量级锁 - 并发量大时，就会进入重量级锁。使用的是互斥锁。

synchronized方法：就会标识ACC_SYNCHRONIZED，最后由monitor实现
synchronized代码块：直接使用了monitorenter 和 monitorexit 指令。

参考文章：

synchronized的原理
synchronized原理详解

1.5. volatile 可见性

volatile 使用了内存屏障，读的时候使用读屏障，写的时候使用写屏障，保证了数据都是从主内存中获取。线程不安全

1.6. ReentrantLock 可重入锁

ReentrantLock继承于Lock

ReentrantLock 包含公平锁和非公平锁，通过构造方法设置，默认是非公平锁。

常用的方法：

lock 加锁
tryLock 尝试获取锁，分为两种方式，一种一直等待获取锁，一种在有效时间内获取锁，获取不了锁，就返回false。
lockInterruptibly 中断等待获取锁的线程
unlock 解锁
newCondition 创建条件，等待与唤醒，与线程Thread的await和notify类似。有如下方法：
- await 等待线程
- signal 唤醒线程

1.7. AQS

AQS 全称 AbstractQueuedSynchronizer，为实现依赖于先进先出 (FIFO) 等待队列的阻塞锁定和相关同步器（信号量、事件，等等）提供一个框架。

AbstractQueuedSynchronizer 抽象队列同步器，里面维护了一个FIFO队列，实现类有：
- Sync 同步锁，实现类有：
  - NonfairSync 非公平锁
  - FairSync 公平锁

应用于AQS的类有:
CountDownLatch、ReentrantLock、 ReentrantReadWriteLock、 Semaphore、 ThreadPoolExecutor

1.8. ReentrantReadWriteLock 可重入读写锁

ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
ReentrantReadWriteLock.ReadLock readLock = lock.readLock();// 读锁
ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();// 写锁

ReentrantReadWriteLock 读写锁
- WriteLock 使用了AQS中的独占锁，具有排它性。
- ReadLock 使用了AQS中的共享锁，允许多个线程读。

读锁和写锁都会导致线程阻塞。

锁降级：还允许将写锁降级为读锁，方法是先获取写锁，再获取读锁，然后释放写锁。然而，无法从读锁升级到写锁。不然就会死锁。


 public void updateData(){

    writeLock.lock();
    readLock.lock();
    
    out(">>"+"->updateData"+"->hello world!"+source);
   
    writeLock.unlock();
    readLock.unlock();
}

不允许读锁后进行写锁，会导致死锁的。

2. 分布式锁

基于数据库的分布式锁
- 原理：利用插入锁记录。
基于Redis的分布式锁
- 原理：利用setNX 设置一个键，仅在键不存在时设置键成功。
- 工具：Redisson已经帮我们封装好分布式锁。解决了分布式锁过期续期问题。
基于ZooKeeper的分布式锁
- 原理：利用临时顺序节点

3. 额外的

3.1. synchronized 的锁升级原理

synchronized 的锁升级指的是在不同的情况下，synchronized 锁的状态会从偏向锁、轻量级锁、重量级锁等级别逐步升级的过程。在 Java 6 及之前的版本中，synchronized 的锁升级过程是固定的，而在 Java 6 及之后的版本中，锁升级过程是根据当前锁的状态和竞争情况动态调整的。

偏向锁：当一个线程访问同步块并获取锁时，会在对象头中记录锁偏向的线程 ID，以后该线程再次进入同步块时，只需判断当前线程 ID 是否与对象头中记录的线程 ID 相同，如果相同，就可以直接进入同步块，无需进行额外的同步操作。如果有其他线程竞争锁，则偏向锁会被撤销。

轻量级锁：当一个线程获取锁失败时，会尝试使用轻量级锁来提高性能。轻量级锁是通过将对象头中的信息复制到线程的栈帧中，然后在栈帧中进行同步操作来实现的。如果在同步过程中发生竞争，则轻量级锁会升级为重量级锁。

重量级锁：当多个线程竞争同一个锁时，会升级为重量级锁。重量级锁是通过操作系统的互斥量来实现的，每次加锁和释放锁都需要进行系统调用，开销较大。

在 Java 6 及之前的版本中，锁升级过程是固定的，即从偏向锁升级到轻量级锁，再升级到重量级锁。而在 Java 6 及之后的版本中，锁升级过程是根据当前锁的状态和竞争情况动态调整的，可以根据实际情况选择偏向锁、轻量级锁或重量级锁，从而提高程序的性能。

参考文章：