为啥虚拟线程在同步块里会被固定？这个问题困扰了Java开发者很久。JDK 21引入虚拟线程后，确实解决了高并发场景下的线程创建成本问题，一个应用可以轻松创建几百万个虚拟线程，不用再担心线程池大小限制了。但有个问题一直没解决：虚拟线程在同步块里执行的时候，会把底层的载体线程（carrier thread）给"固定"住，这个载体线程就不能再处理其他虚拟线程了，并发能力就下来了。
鹏磊我之前就遇到过这种破事，一个Web服务器用虚拟线程处理请求，本来想着能处理更多并发请求，结果发现性能提升不明显。后来一查，发现很多虚拟线程都在同步块里执行，载体线程被固定了，不能复用，并发能力没提升多少。特别是那种同步操作多的场景，比如用synchronized保护共享资源，虚拟线程的优势就发挥不出来了。
现在好了，JDK 24的JEP 491（虚拟线程无固定同步）终于把这个痛点给解决了。这个特性让虚拟线程在同步块里执行的时候，不会固定载体线程，载体线程可以释放出来处理其他虚拟线程，并发能力更强了。兄弟们别磨叽，咱这就开始整活，把这个特性给整明白。
什么是虚拟线程同步固定
先说说啥是同步固定（Pinning）。虚拟线程是轻量级线程，由JVM管理，运行在载体线程（平台线程）上。当虚拟线程执行同步操作（比如synchronized块）的时候，如果同步的对象是原生对象（native object），虚拟线程就会把载体线程固定住，这个载体线程就不能再处理其他虚拟线程了，直到同步操作完成。
为啥要固定呢？因为同步操作需要保证原子性，如果虚拟线程在同步块里被挂起，载体线程去处理其他虚拟线程了，那同步的原子性就保证不了了。所以JVM的策略是：虚拟线程在同步块里执行的时候，固定载体线程，不让它去处理其他虚拟线程。
但这样有个问题：如果很多虚拟线程都在同步块里执行，载体线程都被固定了，就不能复用，并发能力就下来了。特别是那种同步操作多的场景，比如用synchronized保护共享资源，虚拟线程的优势就发挥不出来了。
JEP 491 的核心改进
JEP 491是JDK 24引入的一个特性，主要做了这么几件事：
- 无固定同步：虚拟线程在同步块里执行的时候，不会固定载体线程，载体线程可以释放出来处理其他虚拟线程
- 同步优化：优化了同步机制，让虚拟线程在同步时可以更高效地挂起和恢复
- 并发能力提升：载体线程可以复用，并发能力更强，特别适合高并发场景
- 向后兼容：不影响现有代码，虚拟线程的API和用法都没变
这个特性是正式特性，不是预览或实验性的，可以直接用。但要注意，不是所有同步操作都能无固定，有些特殊情况可能还是会固定，比如那些需要特殊处理的同步场景。
虚拟线程同步机制
虚拟线程的同步机制和平台线程不太一样。平台线程的同步是直接操作操作系统线程，虚拟线程的同步需要JVM特殊处理。JEP 491优化了这个机制，让虚拟线程在同步时可以更高效地挂起和恢复。
同步固定的原因
以前虚拟线程在同步块里会被固定，主要有这么几个原因：
- 原子性保证：同步操作需要保证原子性，如果虚拟线程在同步块里被挂起，载体线程去处理其他虚拟线程了，那同步的原子性就保证不了了
- 锁状态管理：同步对象的锁状态需要正确管理，如果虚拟线程挂起后载体线程去处理其他虚拟线程，锁状态可能不一致
- 性能考虑：固定载体线程可以避免频繁的挂起和恢复，性能可能更好
但这些原因在JEP 491里都被优化了，虚拟线程现在可以在同步时挂起，载体线程可以释放出来处理其他虚拟线程。
无固定同步的实现
JEP 491通过优化同步机制，让虚拟线程在同步时可以挂起，载体线程可以释放。具体怎么实现的？这是JVM内部的优化，咱不用关心细节，知道能用就行。关键是虚拟线程现在可以在同步块里挂起，载体线程可以复用，并发能力更强了。
实际应用场景
虚拟线程无固定同步适合哪些场景呢？鹏磊我觉得主要有这么几类：
1. Web服务器
Web服务器要处理大量并发请求，每个请求可能都要访问共享资源，用synchronized保护。以前虚拟线程在同步块里会被固定，载体线程不能复用，并发能力没提升多少。现在无固定同步后，载体线程可以复用，并发能力更强了。
// Web服务器示例
public class WebServer {
// 共享资源，用synchronized保护
private final Map<String, Object> cache = new HashMap<>();
// 处理请求
public void handleRequest(String requestId) {
// 创建虚拟线程处理请求
Thread.ofVirtual().start(() -> {
// 访问共享资源，用synchronized保护
synchronized (cache) {
// 在JDK 24中，虚拟线程在同步块里不会固定载体线程
// 载体线程可以释放出来处理其他虚拟线程
Object data = cache.get(requestId);
if (data == null) {
// 从数据库加载数据
data = loadFromDatabase(requestId);
cache.put(requestId, data);
}
// 处理数据
processData(data);
}
});
}
private Object loadFromDatabase(String requestId) {
// 模拟数据库查询
try {
Thread.sleep(100); // 模拟I/O操作
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
return "data for " + requestId;
}
private void processData(Object data) {
// 处理数据逻辑
System.out.println("处理数据: " + data);
}
}
2. 数据库连接池
数据库连接池要管理连接，访问连接池的时候可能要用synchronized保护。以前虚拟线程在同步块里会被固定，载体线程不能复用。现在无固定同步后，载体线程可以复用，并发能力更强了。
// 数据库连接池示例
public class ConnectionPool {
private final Queue<Connection> availableConnections = new LinkedList<>();
private final Set<Connection> usedConnections = new HashSet<>();
private final int maxSize;
public ConnectionPool(int maxSize) {
this.maxSize = maxSize;
// 初始化连接池
for (int i = 0; i < maxSize; i++) {
availableConnections.offer(createConnection());
}
}
// 获取连接
public Connection getConnection() throws InterruptedException {
// 创建虚拟线程处理
return Thread.ofVirtual().start(() -> {
// 访问连接池，用synchronized保护
synchronized (this) {
// 在JDK 24中，虚拟线程在同步块里不会固定载体线程
// 载体线程可以释放出来处理其他虚拟线程
while (availableConnections.isEmpty()) {
try {
wait(); // 等待连接可用
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
}
Connection conn = availableConnections.poll();
usedConnections.add(conn);
return conn;
}
}).join();
}
// 释放连接
public void releaseConnection(Connection conn) {
Thread.ofVirtual().start(() -> {
// 访问连接池，用synchronized保护
synchronized (this) {
// 在JDK 24中，虚拟线程在同步块里不会固定载体线程
usedConnections.remove(conn);
availableConnections.offer(conn);
notify(); // 通知等待的线程
}
});
}
private Connection createConnection() {
// 创建数据库连接
return new Connection();
}
}
3. 消息队列处理
消息队列要处理大量消息，访问队列的时候可能要用synchronized保护。以前虚拟线程在同步块里会被固定，载体线程不能复用。现在无固定同步后，载体线程可以复用，并发能力更强了。
// 消息队列处理示例
public class MessageQueue {
private final Queue<Message> queue = new LinkedList<>();
private final int maxSize;
public MessageQueue(int maxSize) {
this.maxSize = maxSize;
}
// 发送消息
public void send(Message message) throws InterruptedException {
Thread.ofVirtual().start(() -> {
// 访问队列，用synchronized保护
synchronized (this) {
// 在JDK 24中，虚拟线程在同步块里不会固定载体线程
// 载体线程可以释放出来处理其他虚拟线程
while (queue.size() >= maxSize) {
try {
wait(); // 等待队列有空间
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
}
queue.offer(message);
notify(); // 通知等待的线程
}
});
}
// 接收消息
public Message receive() throws InterruptedException {
return Thread.ofVirtual().start(() -> {
// 访问队列，用synchronized保护
synchronized (this) {
// 在JDK 24中，虚拟线程在同步块里不会固定载体线程
while (queue.isEmpty()) {
try {
wait(); // 等待消息
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
}
Message message = queue.poll();
notify(); // 通知等待的线程
return message;
}
}).join();
}
}
性能影响分析
启用虚拟线程无固定同步后，性能会有啥变化？鹏磊我总结了一下：
并发能力提升
最明显的就是并发能力提升了。载体线程可以复用，不用再被固定，可以处理更多虚拟线程，并发能力更强了。特别是那种同步操作多的场景，比如Web服务器、数据库连接池，效果更明显。
资源利用率提升
载体线程可以复用，资源利用率更高了。以前载体线程被固定，不能处理其他虚拟线程，资源浪费。现在载体线程可以复用，资源利用率更高了。
响应时间降低
并发能力提升了，响应时间自然就降了。特别是那种高并发场景，比如Web服务器处理大量请求，响应时间能降不少。
可能的负面影响
虽然整体是正向的，但也有一些需要注意的地方：
- 同步开销：虚拟线程在同步时挂起和恢复需要开销，如果同步操作特别频繁，可能影响性能
- 锁竞争：载体线程可以复用，锁竞争可能更激烈，需要合理设计同步策略
- 调试难度：虚拟线程挂起和恢复更频繁，调试可能更复杂
最佳实践
用虚拟线程无固定同步的时候，鹏磊我建议注意这么几点：
1. 合理使用同步
虽然虚拟线程现在可以在同步时挂起，但同步操作还是有开销的。能不用同步就不用，能用其他机制（比如Lock、原子类）就用其他机制，减少同步操作。
// 推荐：使用原子类代替synchronized
public class Counter {
private final AtomicInteger count = new AtomicInteger(0);
public void increment() {
// 使用原子类，不需要同步
count.incrementAndGet();
}
public int get() {
return count.get();
}
}
// 不推荐：过度使用synchronized
public class CounterBad {
private int count = 0;
public synchronized void increment() {
// 过度使用synchronized，可能影响性能
count++;
}
public synchronized int get() {
return count;
}
}
2. 减少同步块大小
同步块越小越好，能快速执行完，减少挂起和恢复的开销。如果同步块太大，虚拟线程挂起时间长，可能影响性能。
// 推荐：同步块小
public void processData(Object data) {
// 只在必要时同步
Object result;
synchronized (this) {
result = cache.get(data);
}
// 同步块外处理数据
processResult(result);
}
// 不推荐：同步块大
public void processDataBad(Object data) {
synchronized (this) {
// 同步块太大，虚拟线程挂起时间长
Object result = cache.get(data);
processResult(result); // 不需要同步的操作也在同步块里
updateCache(result);
}
}
3. 使用并发集合
能用并发集合就用并发集合，比如ConcurrentHashMap、ConcurrentLinkedQueue，这些集合内部已经做了并发优化，不需要额外的同步。
// 推荐：使用并发集合
public class Cache {
private final ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();
public void put(String key, Object value) {
// 不需要同步，ConcurrentHashMap内部已经做了并发优化
map.put(key, value);
}
public Object get(String key) {
return map.get(key);
}
}
// 不推荐：使用普通集合加同步
public class CacheBad {
private final HashMap<String, Object> map = new HashMap<>();
public synchronized void put(String key, Object value) {
// 需要同步，可能影响性能
map.put(key, value);
}
public synchronized Object get(String key) {
return map.get(key);
}
}
4. 监控虚拟线程状态
启用后要监控虚拟线程状态，看看有没有问题。可以用JVM监控工具，比如jstack、VisualVM，观察虚拟线程的挂起和恢复情况。
# 查看虚拟线程状态
jstack <pid> | grep -A 10 "VirtualThread"
# 或者用VisualVM查看
# 可以看到虚拟线程的挂起和恢复情况
5. 测试并发性能
启用前要做并发性能测试，看看性能有没有提升。可以用JMH做基准测试，对比启用前后的性能差异。
// 性能测试示例
@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
public class VirtualThreadBenchmark {
@Benchmark
public void testSynchronized() {
Thread.ofVirtual().start(() -> {
synchronized (this) {
// 测试同步性能
doWork();
}
});
}
private void doWork() {
// 模拟工作
try {
Thread.sleep(10);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
}
}
}
与其他特性结合
虚拟线程无固定同步可以和其他JDK特性结合使用，效果更好：
1. 结构化并发（JEP 499）
结构化并发可以把相关的并发任务当成一个整体来管理，出错处理、取消操作都更简单。和虚拟线程无固定同步一起用，并发管理更方便。
// 结合结构化并发
try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
// 创建多个虚拟线程任务
var task1 = scope.fork(() -> {
synchronized (this) {
// 虚拟线程在同步块里不会固定载体线程
return processTask1();
}
});
var task2 = scope.fork(() -> {
synchronized (this) {
return processTask2();
}
});
// 等待所有任务完成
scope.join();
// 处理结果
var result1 = task1.get();
var result2 = task2.get();
}
2. 作用域值（JEP 487）
作用域值可以在线程内和跨线程共享不可变数据，比ThreadLocal更安全。和虚拟线程无固定同步一起用，数据共享更方便。
// 结合作用域值
final ScopedValue<String> USER_ID = ScopedValue.newInstance();
ScopedValue.runWhere(USER_ID, "user123", () -> {
Thread.ofVirtual().start(() -> {
synchronized (this) {
// 虚拟线程在同步块里不会固定载体线程
// 可以访问作用域值
String userId = USER_ID.get();
processUser(userId);
}
});
});
常见问题
Q1: 所有同步操作都能无固定吗？
不是。大部分同步操作都能无固定，但有些特殊情况可能还是会固定，比如那些需要特殊处理的同步场景。JVM会自动处理，不需要改代码。
Q2: 无固定同步会影响同步的正确性吗？
不会。无固定同步只是优化了同步机制，同步的正确性不受影响。虚拟线程在同步时挂起，锁状态会正确保存，恢复后会继续执行。
Q3: 启用无固定同步后性能一定会提升吗？
不一定。虽然理论上能提升，但实际效果要看具体场景。同步操作多的应用提升更明显，同步操作少的应用可能没啥变化。建议先做性能测试。
Q4: 无固定同步和平台线程的同步有什么区别？
平台线程的同步是直接操作操作系统线程，虚拟线程的同步需要JVM特殊处理。无固定同步优化了虚拟线程的同步机制，让虚拟线程在同步时可以挂起，载体线程可以复用。
Q5: 如何判断虚拟线程是否被固定？
可以用JVM参数 -XX:+PrintPinning 打印固定信息，或者用JFR（Java Flight Recorder）记录虚拟线程的固定情况。
# 打印固定信息
java -XX:+PrintPinning -jar myapp.jar
# 或者用JFR记录
java -XX:StartFlightRecording=filename=recording.jfr -jar myapp.jar
总结
虚拟线程无固定同步（JEP 491）是JDK 24引入的一个特性，可以大幅提升虚拟线程的并发能力。它优化了虚拟线程的同步机制，让虚拟线程在同步块里执行的时候，不会固定载体线程，载体线程可以释放出来处理其他虚拟线程，并发能力更强了。
特别适合高并发场景，比如Web服务器、数据库连接池、消息队列处理，这些场景同步操作多，无固定同步后载体线程可以复用，并发能力能提升不少。
使用要注意合理使用同步、减少同步块大小、使用并发集合、监控虚拟线程状态、测试并发性能。可以和其他JDK特性结合使用，效果更好。
虽然有一些需要注意的地方，但整体是正向的，并发能力能提升不少。兄弟们可以试试，特别是那种同步操作多的场景，效果更明显。并发能力强了，响应时间降了，用户体验更好，何乐而不为呢？