Java自旋锁与读写锁的实现原理

import java.util.concurrent.atomic.AtomicReference;
/**
 * 简单的自旋锁实现
 * 核心：利用AtomicReference的CAS操作保证锁的原子性竞争
 */
public class SimpleSpinLock {
    // 用AtomicReference存储持有锁的线程，初始为null（无锁状态）
    private final AtomicReference<Thread> lockOwner = new AtomicReference<>();
    // 获取锁（自旋逻辑）
    public void lock() {
        Thread currentThread = Thread.currentThread();
        // 自旋：CAS尝试将lockOwner从null改为当前线程，失败则循环重试
        while (!lockOwner.compareAndSet(null, currentThread)) {
            // 空循环（自旋），也可以加入自旋次数限制、yield()等优化
            // Thread.yield(); // 让出CPU，减少空转消耗
        }
        System.out.println(currentThread.getName() + " 获取到锁");
    }
    // 释放锁
    public void unlock() {
        Thread currentThread = Thread.currentThread();
        // 只有持有锁的线程才能释放锁
        if (lockOwner.get() == currentThread) {
            lockOwner.compareAndSet(currentThread, null);
            System.out.println(currentThread.getName() + " 释放了锁");
        } else {
            throw new IllegalMonitorStateException("当前线程未持有锁，无法释放");
        }
    }
    // 测试自旋锁
    public static void main(String[] args) {
        SimpleSpinLock spinLock = new SimpleSpinLock();
        // 创建5个线程竞争锁
        for (int i = 0; i < 5; i++) {
            new Thread(() -> {
                try {
                    spinLock.lock();
                    // 模拟持有锁的短时间操作（自旋锁适合短任务）
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    spinLock.unlock();
                }
            }, "线程" + i).start();
        }
    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;
/**
 * 基于读写锁实现的线程安全缓存
 * 场景：多读少写，读操作并行，写操作独占
 */
public class ReadWriteLockCache {
    // 缓存容器
    private final Map<String, Object> cache = new HashMap<>();
    // 读写锁（默认非公平模式）
    private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    // 读锁（共享锁）
    private final ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();
    // 写锁（排他锁）
    private final ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();
    // 从缓存读取数据（读操作，用读锁）
    public Object get(String key) {
        // 获取读锁
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 读取缓存，key=" + key);
            // 模拟读操作耗时
            Thread.sleep(100);
            return cache.get(key);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            return null;
        } finally {
            // 释放读锁（必须在finally中释放，避免锁泄漏）
            readLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 释放读锁");
        }
    }
    // 向缓存写入数据（写操作，用写锁）
    public void put(String key, Object value) {
        // 获取写锁
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 写入缓存，key=" + key + ", value=" + value);
            // 模拟写操作耗时
            Thread.sleep(200);
            cache.put(key, value);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            // 释放写锁
            writeLock.unlock();
            System.out.println(Thread.currentThread().getName() + " 释放写锁");
        }
    }
    // 清空缓存（写操作，用写锁）
    public void clear() {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 清空缓存");
            cache.clear();
        } finally {
            writeLock.unlock();
        }
    }
    // 测试读写锁
    public static void main(String[] args) {
        ReadWriteLockCache cache = new ReadWriteLockCache();
        // 1. 启动5个读线程（并行执行）
        for (int i = 0; i < 5; i++) {
            new Thread(() -> cache.get("user_1"), "读线程" + i).start();
        }
        // 2. 启动2个写线程（串行执行，且阻塞读线程）
        new Thread(() -> cache.put("user_1", "张三"), "写线程1").start();
        new Thread(() -> cache.put("user_2", "李四"), "写线程2").start();
    }
}

// 写锁降级为读锁
writeLock.lock();
try {
    // 执行写操作
    cache.put("key", "value");
    // 降级：先获取读锁，再释放写锁
    readLock.lock();
} finally {
    writeLock.unlock();
}
try {
    // 持有读锁，安全读取数据
    System.out.println(cache.get("key"));
} finally {
    readLock.unlock();
}