Java中的锁实现原理及优缺点

# Java中的锁实现原理及优缺点

## 目录
1. [锁的基本概念与分类](#一锁的基本概念与分类)
2. [synchronized实现原理](#二synchronized实现原理)
3. [AQS与显式锁实现](#三aqs与显式锁实现)
4. [乐观锁实现机制](#四乐观锁实现机制)
5. [分布式锁实现方案](#五分布式锁实现方案)
6. [锁的性能优化策略](#六锁的性能优化策略)
7. [总结与选型建议](#七总结与选型建议)

---

## 一、锁的基本概念与分类

### 1.1 为什么需要锁
在多线程并发环境中，当多个线程同时访问共享资源时，可能导致：
- **竞态条件**（Race Condition）
- **数据不一致**（Data Inconsistency）
- **内存可见性问题**（Visibility Issues）

### 1.2 Java锁的分类维度
| 分类维度       | 类型                  | 典型实现                     |
|----------------|-----------------------|------------------------------|
| 获取方式       | 隐式锁                | synchronized                 |
|                | 显式锁                | ReentrantLock                |
| 线程竞争策略   | 悲观锁                | synchronized, ReentrantLock  |
|                | 乐观锁                | CAS, StampedLock             |
| 可重入性       | 可重入锁              | ReentrantLock                |
|                | 非重入锁              | -                            |
| 公平性         | 公平锁                | new ReentrantLock(true)      |
|                | 非公平锁              | new ReentrantLock(false)     |
| 共享模式       | 独占锁                | ReentrantLock                |
|                | 共享锁                | Semaphore, ReadWriteLock     |

---

## 二、synchronized实现原理

### 2.1 对象内存布局
```java
// 对象头结构（64位JVM）
|-------------------------------------------------------|
| Mark Word (64bits)                  | Klass Word      |
|-------------------------------------------------------|

Mark Word在不同状态下的存储内容：

锁状态	25bit	4bit	1bit(偏向锁)	2bit(锁标志)
无锁	hashCode	分代年龄	0	01
偏向锁	线程ID+Epoch	分代年龄	1	01
轻量级锁	指向栈中锁记录	-	-	00
重量级锁	指向Monitor	-	-	10

2.2 锁升级过程

1. 偏向锁（Biased Locking）

   • 适用场景：单线程重复访问
   • 优点：无同步开销
   • 缺点：存在撤销成本

2. 轻量级锁（Lightweight Lock）

   • 通过CAS替换Mark Word
   • 适用场景：低竞争环境

3. 重量级锁（Heavyweight Lock）

   • 依赖操作系统Mutex实现
   • 涉及线程阻塞/唤醒

2.3 优缺点分析

优点： - JVM内置支持，自动释放 - 锁升级机制优化性能

缺点： - 无法实现锁超时 - 不支持中断响应

---

三、AQS与显式锁实现

3.1 AQS核心设计

// AbstractQueuedSynchronizer关键结构
public abstract class AbstractQueuedSynchronizer {
    volatile Node head;    // CLH队列头节点
    volatile Node tail;    // CLH队列尾节点
    volatile int state;    // 同步状态
    
    static final class Node {
        volatile int waitStatus;
        volatile Node prev;
        volatile Node next;
        volatile Thread thread;
    }
}

3.2 ReentrantLock实现

公平锁实现：

protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        if (!hasQueuedPredecessors() && 
            compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    // 处理重入逻辑...
}

3.3 与synchronized对比

特性	ReentrantLock	synchronized
实现方式	Java代码实现	JVM内置实现
锁获取方式	显式lock()/unlock()	隐式获取
可中断	支持	不支持
公平性选择	可配置	非公平
条件变量	多Condition支持	单条件等待

---

四、乐观锁实现机制

4.1 CAS原理

// Unsafe类中的CAS操作
public final native boolean compareAndSwapInt(
    Object o, long offset, 
    int expected, int x);

4.2 典型实现对比

1. AtomicInteger

   public final int incrementAndGet() {
      return unsafe.getAndAddInt(this, valueOffset, 1) + 1;
   }
   

2. StampedLock

   public long tryOptimisticRead() {
      long s;
      return (((s = state) & WBIT) == 0L) ? (s & SBITS) : 0L;
   }
   

4.3 ABA问题解决方案

// 使用AtomicStampedReference
AtomicStampedReference<String> ref = new AtomicStampedReference<>("A", 0);
int stamp = ref.getStamp();
ref.compareAndSet("A", "B", stamp, stamp+1);

---

五、分布式锁实现方案

5.1 常见实现对比

方案	实现原理	优点	缺点
Redis	SETNX + Lua脚本	高性能	需处理续约问题
Zookeeper	临时顺序节点	高可靠性	性能较低
数据库	唯一约束/乐观锁	实现简单	性能差

5.2 RedLock算法

// Redisson实现示例
RLock lock1 = redisson1.getLock("lock");
RLock lock2 = redisson2.getLock("lock");
RLock lock3 = redisson3.getLock("lock");

RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
lock.lock();
try {
    // 业务逻辑
} finally {
    lock.unlock();
}

---

六、锁的性能优化策略

6.1 减少锁粒度

错误示例：

synchronized(this) {  // 锁整个对象
    // 访问所有字段
}

优化方案：

private final Object fieldLock = new Object();

synchronized(fieldLock) {  // 只锁特定字段
    // 访问对应字段
}

6.2 读写分离

ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
rwLock.readLock().lock();   // 读操作
rwLock.writeLock().lock();  // 写操作

6.3 锁消除示例

// 经过JIT编译后会消除锁
public String concat(String s1, String s2) {
    StringBuffer sb = new StringBuffer();
    sb.append(s1);  // 同步方法但无竞争
    sb.append(s2);
    return sb.toString();
}

---

七、总结与选型建议

7.1 选型决策树

graph TD
    A[需要分布式协调?] -->|是| B[选择Redis/ZK方案]
    A -->|否| C{需要阻塞等待?}
    C -->|是| D[考虑ReentrantLock特性需求]
    C -->|否| E[优先考虑CAS+自旋]
    D --> F{需要公平性?}
    F -->|是| G[公平锁]
    F -->|否| H[非公平锁]

7.2 性能指标参考

锁类型	吞吐量(ops/ms)	延迟(μs)
无锁	1200	0.8
CAS	850	1.2
偏向锁	600	1.6
轻量级锁	400	2.5
重量级锁	150	6.8
ReentrantLock	320	3.1

注：测试环境为4核CPU，基准测试数据仅供参考 “`