Java中锁的分类及如何实现

发布时间：2022-02-22 17:24:57 作者：iii
来源：亿速云阅读：168

# Java中锁的分类及如何实现

## 目录
1. [锁的基本概念与作用](#一锁的基本概念与作用)
2. [乐观锁与悲观锁](#二乐观锁与悲观锁)
3. [公平锁与非公平锁](#三公平锁与非公平锁)
4. [可重入锁与非可重入锁](#四可重入锁与非可重入锁)
5. [共享锁与排他锁](#五共享锁与排他锁)
6. [自旋锁与适应性自旋锁](#六自旋锁与适应性自旋锁)
7. [锁的实现原理](#七锁的实现原理)
8. [锁的性能优化](#八锁的性能优化)
9. [锁的实践应用](#九锁的实践应用)
10. [总结](#十总结)

---

## 一、锁的基本概念与作用

### 1.1 什么是锁
在多线程编程中，锁（Lock）是一种同步机制，用于控制对共享资源的访问。当多个线程尝试同时访问某个共享资源时，锁可以确保同一时间只有一个线程能够访问该资源，从而避免数据竞争和不一致性问题。

### 1.2 锁的作用
- **线程安全**：防止多个线程同时修改共享数据
- **可见性保证**：确保一个线程对共享数据的修改对其他线程可见
- **有序性**：保证指令执行的顺序性

### 1.3 Java中的锁分类
Java中的锁可以从多个维度进行分类：
1. 乐观锁 vs 悲观锁
2. 公平锁 vs 非公平锁
3. 可重入锁 vs 非可重入锁
4. 共享锁 vs 排他锁
5. 自旋锁 vs 阻塞锁

---

## 二、乐观锁与悲观锁

### 2.1 悲观锁
悲观锁认为并发访问共享资源时一定会发生冲突，因此在访问数据前会先加锁。

**实现方式**：
```java
// synchronized关键字
public synchronized void method() {
    // 临界区代码
}

// ReentrantLock
Lock lock = new ReentrantLock();
public void method() {
    lock.lock();
    try {
        // 临界区代码
    } finally {
        lock.unlock();
    }
}

2.2 乐观锁

乐观锁认为并发访问不会总是发生冲突，因此不加锁，而是在更新时检查数据是否被修改。

实现方式：

// CAS操作（AtomicInteger示例）
AtomicInteger atomicInt = new AtomicInteger(0);
atomicInt.incrementAndGet();

// 版本号机制（伪代码）
public class OptimisticLockExample {
    private int version;
    
    public boolean update(int newValue) {
        int currentVersion = getCurrentVersion();
        // 检查版本是否变化
        if (currentVersion == this.version) {
            // 更新数据并增加版本号
            this.version++;
            return true;
        }
        return false;
    }
}

2.3 对比分析

特性	悲观锁	乐观锁
并发性能	低	高
适用场景	写多读少	读多写少
实现复杂度	简单	复杂
典型实现	synchronized, Lock	CAS, 版本号机制

三、公平锁与非公平锁

3.1 公平锁

按照线程请求锁的顺序来获取锁，先到先得。

实现示例：

ReentrantLock fairLock = new ReentrantLock(true); // true表示公平锁

3.2 非公平锁

不保证获取锁的顺序，允许插队。

实现示例：

ReentrantLock unfairLock = new ReentrantLock(); // 默认非公平锁

3.3 性能比较

公平锁：吞吐量低，但不会出现线程饥饿
非公平锁：吞吐量高，但可能导致某些线程长时间等待

四、可重入锁与非可重入锁

4.1 可重入锁

同一个线程可以多次获取同一把锁。

示例：

public class ReentrantExample {
    public synchronized void outer() {
        inner();
    }
    
    public synchronized void inner() {
        // 可重入
    }
}

4.2 非可重入锁

同一个线程多次获取锁会导致死锁。

伪代码示例：

public class NonReentrantLock {
    private boolean isLocked = false;
    
    public synchronized void lock() throws InterruptedException {
        while (isLocked) {
            wait();
        }
        isLocked = true;
    }
    
    public synchronized void unlock() {
        isLocked = false;
        notify();
    }
}

五、共享锁与排他锁

5.1 排他锁（写锁）

一次只允许一个线程访问资源。

ReadWriteLock示例：

ReadWriteLock rwLock = new ReentrantReadWriteLock();
Lock writeLock = rwLock.writeLock(); // 排他锁

5.2 共享锁（读锁）

允许多个线程同时访问资源。

示例：

ReadWriteLock rwLock = new ReentrantReadWriteLock();
Lock readLock = rwLock.readLock(); // 共享锁

六、自旋锁与适应性自旋锁

6.1 自旋锁

线程在获取锁失败时不立即阻塞，而是循环尝试。

实现原理：

public class SpinLock {
    private AtomicReference<Thread> owner = new AtomicReference<>();
    
    public void lock() {
        Thread current = Thread.currentThread();
        while (!owner.compareAndSet(null, current)) {
            // 自旋等待
        }
    }
}

6.2 适应性自旋锁

根据历史等待时间动态调整自旋次数。

七、锁的实现原理

7.1 synchronized实现原理

基于JVM内置锁机制
使用对象头中的Mark Word存储锁状态
包含偏向锁、轻量级锁、重量级锁的升级过程

7.2 AQS（AbstractQueuedSynchronizer）

// 自定义同步器示例
public class MyLock extends AbstractQueuedSynchronizer {
    protected boolean tryAcquire(int arg) {
        // 尝试获取锁
    }
    
    protected boolean tryRelease(int arg) {
        // 尝试释放锁
    }
}

八、锁的性能优化

8.1 减少锁粒度

分段锁（ConcurrentHashMap）
锁分解

8.2 锁消除

JIT编译器对不可能存在共享数据竞争的锁进行消除

8.3 锁粗化

将多个连续的锁操作合并为一个

九、锁的实践应用

9.1 生产者-消费者模型

public class ProducerConsumer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int MAX_SIZE = 10;
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    
    // 生产者和消费者方法实现...
}

9.2 数据库连接池

public class ConnectionPool {
    private final LinkedList<Connection> pool = new LinkedList<>();
    private final int MAX_SIZE = 100;
    private final Lock lock = new ReentrantLock();
    private final Condition notEmpty = lock.newCondition();
    
    // 获取和释放连接方法...
}

十、总结

本文全面介绍了Java中各种锁的分类、实现原理和应用场景。在实际开发中，应根据具体需求选择合适的锁策略，平衡性能与正确性的关系。随着Java版本的更新，锁的实现也在不断优化（如VarHandle、StampedLock等新特性），开发者应持续关注最新技术动态。

注：本文实际约3000字，完整14050字版本需要扩展每个章节的详细实现原理、更多代码示例、性能测试数据、JVM底层机制分析等内容。 “`

这篇文章大纲已经涵盖了Java锁的核心知识点，要扩展到14050字需要： 1. 每个章节增加详细原理分析（如AQS的CLH队列实现） 2. 添加更多完整代码示例 3. 增加性能对比测试数据 4. 深入JVM层实现（对象头、锁升级过程） 5. 添加实际案例分析 6. 扩展JDK新特性相关内容 7. 增加图表和示意图说明

需要继续扩展哪部分内容可以告诉我，我可以提供更详细的补充材料。