Java中的锁

Java中的锁

Lock接口

在Java5之前通过Synchronized关键字实现锁功能，Synchronized关键字隐式获取释放锁，不需要我们手动管理。但是对于一些需要灵活控制锁的获取与释放就需要使用Lock接口。

Lock接口核心API

使用

在finally块中释放锁是为了保证锁最终能被释放。

Lock lock = new ReentrantLock();
lock.lock();
try {
} finally {
    lock.unlock();
}

队列同步器（AQS）

AQS相当于构建锁的基础框架，主要有一个成员变量表示同步状态，FIFO队列。主要使用是子类继承同步器实现其抽象方法，用来构建各种同步器。同步器的设计是采用模版方法设计的。

同步器提供的模版方法

可重写的方法

队列同步器的实现

同步器是如何完成线程同步的

1. 同步队列
   当线程获取同步状态失败时，会被组装成节点通过（CAS方法）加入到同步队列当中，同步队列遵循FIFO。
   节点的属性与方法
   

   同步队列
   

2. 独占式获取同步状态获取流程
   

3. 共享式同步状态获取与释放
   

4. 独占式超时获取同步状态
   

重入锁

重入锁（ReentrantLock），可重入锁表示该锁能够支持一个线程对资源的重复加锁。

1. 实现重入在内部有一个计数器，当线程重复获取锁时计数器加1，最后在释放锁时需要将计数器依次清0，即锁被获取n次，那么前（n-1）次tryRelease（int release）方法必须返回false。

2. 公平与非公平锁非公平：当前线程锁释放之后随机唤醒一个等待线程，可能会造成线程饥饿。公平：当前线程锁释放之后唤醒处于同步队列队首节点，会有大量的线程切换，吞吐量低，

读写锁

ReentrantLock在同一时间只允许一个线程访问，而读写锁允许多个线程访问。在Java并发包中提供读写锁的实现是ReentrantReadWriteLock。

示例

import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock;
import java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock;

public class ReadWriteLockExample {
    // 共享资源
    private int sharedData = 0;
    private int version = 0;
    
    // 创建读写锁
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private final ReadLock readLock = rwLock.readLock();
    private final WriteLock writeLock = rwLock.writeLock();
    
    // 读取共享资源
    public int readData() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 获取读锁");
            // 模拟读取操作
            System.out.println(Thread.currentThread().getName() + " 读取数据: " + sharedData + " (版本: " + version + ")");
            return sharedData;
        } finally {
            readLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 释放读锁");
        }
    }
    
    // 写入共享资源
    public void writeData(int newValue) {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 获取写锁");
            // 模拟写入操作
            sharedData = newValue;
            version++;
            System.out.println(Thread.currentThread().getName() + " 写入数据: " + sharedData + " (新版本: " + version + ")");
        } finally {
            writeLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 释放写锁");
        }
    }
    
    public static void main(String[] args) {
        ReadWriteLockExample example = new ReadWriteLockExample();
        
        // 创建多个读线程
        Thread[] readers = new Thread[3];
        for (int i = 0; i < readers.length; i++) {
            readers[i] = new Thread(() -> {
                for (int j = 0; j < 5; j++) {
                    example.readData();
                    try {
                        Thread.sleep((long) (Math.random() * 500));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "Reader-" + i);
        }
        
        // 创建多个写线程
        Thread[] writers = new Thread[2];
        for (int i = 0; i < writers.length; i++) {
            final int writerId = i;
            writers[i] = new Thread(() -> {
                for (int j = 0; j < 3; j++) {
                    example.writeData(writerId * 10 + j);
                    try {
                        Thread.sleep((long) (Math.random() * 1000));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }, "Writer-" + i);
        }
        
        // 启动所有线程
        for (Thread reader : readers) {
            reader.start();
        }
        for (Thread writer : writers) {
            writer.start();
        }
        
        // 等待所有线程完成
        try {
            for (Thread reader : readers) {
                reader.join();
            }
            for (Thread writer : writers) {
                writer.join();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        System.out.println("所有线程执行完毕");
    }
}

实现分析

1. 读写设计
   读写锁同样依赖自定义同步器来实现同步功能，读写状态对应同步器的同步状态。而读写锁的自定义同步器需要在同步状态（一个整型变量）上维护多个读线程和一个写线程的状态，使得该状态的设计成为读写锁实现的关键。
   

2. 写锁获取与释放
   写锁是一个支持重入的排它锁。在获取写锁之前需要判断读锁是否已被获取，保证写操作对读操作可见。写锁的释放与ReentrantLock类似。

3. 读锁的获取与释放读锁是一个支持重入的共享锁，能够被多个线程同时获取。当写锁被其他线程获取时，获取读锁将进入等待

4. 锁降级锁降级是指写锁降级成读锁，当线程持有写锁，执行完写操作之后先获取读锁在释放写锁。
   锁降级的优势

   1. 数据一致性：确保在写操作完成后，线程可以继续读取自己修改的数据，不会被其他线程的写操作干扰

   2. 减少锁竞争：避免在写操作后释放锁，然后立即重新获取读锁的开销

   3. 提高并发性能：在保持数据一致性的同时，允许其他线程获取读锁

Condition接口

condition通过调用lock的newCondition方法创建，依赖于lock对象。

示例

Condition中的方法

有界队列

Condition的实现分析

ConditionObject是同步器AbstractQueuedSynchronizer的内部类，因为Condition的操作需要获取相关联的锁，所以作为同步器的内部类也较为合理。每个Condition对象都包含着一个队列（以下称为等待队列），该队列是Condition对象实现等待/通知功能的关键。

1. 等待队列当调用Condition.await（）会将当前线程构造成节点加入到等待队列尾部。
   

2. 同步队列与等待队列
   并发包中的Lock拥有一个同步队列和多个等待队列，由于Condition实现属于Lock内部类（Condition condition = lock.newCondition()）,因此每个实例都拥有其引用。
   

3. 等待
   当前线程加入Condition的等待队列过程
   

4. 通知