我要评论java自旋锁与读写锁
一、自旋锁的核心概念
自旋锁（spin lock）是一种非阻塞锁，它的核心思想是：当线程获取锁失败时，不会立刻进入阻塞（休眠）状态，而是在一个循环中不断尝试获取锁（“自旋”），直到成功获取锁或者达到自旋上限。
二、对比传统阻塞锁（如 synchronized）
- 阻塞锁：获取锁失败 → 线程进入等待队列 → 内核态切换 → 等待被唤醒 → 再次竞争锁（上下文切换成本高）
- 自旋锁：获取锁失败 → 循环重试（用户态） → 成功获取锁（无上下文切换）
自旋锁适合锁持有时间极短的场景，因为短时间的自旋消耗的 cpu 资源，远小于线程上下文切换的开销；但如果锁持有时间长，自旋会浪费大量 cpu 资源（空转）。
三、java 中自旋锁的实现原理
java 中实现自旋锁的核心是cas（compare and swap，比较并交换） 操作，这是一种原子操作，保证多线程下的线程安全。
cas 有三个核心参数：
v：要修改的变量（锁的状态标识）a：预期值（期望的锁状态，比如未被占用）b：新值（修改后的锁状态，比如被当前线程占用）
只有当 v == a 时，才会将 v 更新为 b，否则不做操作，返回 false。
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();
}
}
}四、java 中的内置自旋锁优化
jdk 中并没有直接暴露 “自旋锁” 类，但在底层对synchronized和lock（如 reentrantlock）做了自旋优化：
- synchronized 的自旋优化：jdk1.6 后，synchronized 引入了 “偏向锁→轻量级锁→重量级锁” 的升级过程，其中轻量级锁阶段会采用自旋（默认自旋 10 次，可通过 jvm 参数
-xx:preblockspin调整）。 - locksupport.parknanos()：reentrantlock 的底层（aqs）会在自旋一定次数后，调用
parknanos()让线程短暂休眠，避免无限自旋浪费 cpu（自适应自旋）。
一、读写锁的核心概念
读写锁（readwritelock）是一种共享 - 排他锁，它把对资源的访问分成了 “读操作” 和 “写操作”，核心设计目标是：
- 读锁（共享锁）：多个线程可以同时获取读锁，互不阻塞（读 - 读共享）。
- 写锁（排他锁 / 独占锁）：只有一个线程能获取写锁，且写锁会阻塞所有读锁和其他写锁（写 - 读、写 - 写互斥）。
读写锁的核心规则
| 场景 | 是否允许 |
|---|---|
| 已有读锁，加读锁 | 允许（共享） |
| 已有读锁，加写锁 | 不允许（互斥） |
| 已有写锁，加读锁 | 不允许（互斥） |
| 已有写锁，加写锁 | 不允许（互斥） |
二、java 中的读写锁实现：reentrantreadwritelock
java 在java.util.concurrent.locks包中提供了readwritelock接口，其核心实现类是reentrantreadwritelock（可重入读写锁），它具备以下特性：
- 可重入：读线程获取读锁后可再次获取读锁，写线程获取写锁后可再次获取写锁 / 读锁。
- 公平 / 非公平模式：默认非公平，可通过构造函数指定公平模式。
- 锁降级：写锁可降级为读锁（写锁→读锁），但读锁不能升级为写锁。
“缓存模拟” 案例（典型的多读少写场景），展示读写锁的使用：
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();
}
}运行代码会发现，5 个读线程几乎同时执行（读锁共享），而 2 个写线程串行执行，且写线程执行时读线程会等待。
读线程0 读取缓存，key=user_1
读线程2 读取缓存，key=user_1
读线程1 读取缓存，key=user_1
读线程4 读取缓存，key=user_1
读线程3 读取缓存，key=user_1
读线程1 释放读锁
读线程3 释放读锁
读线程4 释放读锁
读线程2 释放读锁
写线程1 写入缓存，key=user_1, value=张三
读线程0 释放读锁
写线程2 写入缓存，key=user_2, value=李四
写线程1 释放写锁
写线程2 释放写锁
四、读写锁的关键特性详解
1. 可重入性
- 读线程获取读锁后，可再次获取读锁（重入次数累加）。
- 写线程获取写锁后，可再次获取写锁，也可获取读锁（锁降级的基础）。
- 示例（锁降级）：
// 写锁降级为读锁
writelock.lock();
try {
// 执行写操作
cache.put("key", "value");
// 降级：先获取读锁，再释放写锁
readlock.lock();
} finally {
writelock.unlock();
}
try {
// 持有读锁，安全读取数据
system.out.println(cache.get("key"));
} finally {
readlock.unlock();
}2. 公平 / 非公平模式
- 非公平模式（默认）：性能更高，写线程可能插队（读线程多的时候，写线程可能饥饿）。
- 公平模式：通过构造函数
new reentrantreadwritelock(true)指定，按线程等待顺序获取锁，避免写饥饿，但性能略低。
3. 写饥饿问题
如果读操作非常频繁，写线程可能长期无法获取写锁（一直被读锁阻塞），解决方案：
- 使用公平模式。
- 控制读锁持有时间，避免长时间占用读锁。
到此这篇关于java自旋锁与读写锁的实现原理的文章就介绍到这了,更多相关java自旋锁与读写锁内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论