怎么利用 Variable Handles 的 Acquire/Release 语义替代 volatile 实现更细粒度的内存可见性

在Java并发编程场景里，volatile关键字是常用的内存可见性保障手段，但它对所有读写操作都施加完整的内存屏障，粒度较粗，在高频操作的场景下会带来不必要的性能开销。Variable Handles提供的Acquire/Release语义可以针对特定操作施加精准的内存屏障，实现更细粒度的可见性控制。

volatile的局限性

volatile修饰的变量，每次写操作都会插入StoreStore和StoreLoad屏障，每次读操作都会插入LoadLoad和LoadStore屏障，这些屏障会限制指令重排序，同时保证变量的修改对其他线程立即可见。但这种全量屏障的施加方式不够灵活，比如当只需要保证写操作后对其他线程的读可见，不需要限制读操作的屏障时，volatile就无法做到，会带来额外的性能损耗。

Acquire/Release语义的核心特性

Acquire和Release是两种弱化的内存语义，比volatile的完全内存屏障更轻量：

• Release语义：写操作带有Release语义时，该写操作之前的所有读写操作不会被重排序到该写操作之后，且该写操作的结果对其他线程的Acquire读操作可见。
• Acquire语义：读操作带有Acquire语义时，该读操作之后的所有读写操作不会被重排序到该读操作之前，且能读到其他线程Release写操作写入的最新值。

这两种语义不需要像volatile那样施加全量的内存屏障，只在需要的操作上生效，因此可以实现更细粒度的控制。

用Variable Handles实现Acquire/Release语义

Java中的VarHandle类提供了对变量进行Acquire读和Release写的方法，分别是acquireRead和releaseWrite，我们可以借助这两个方法替代volatile的可见性保障，同时减少不必要的屏障。

基础使用示例

首先看一个用volatile实现的简单计数器：

import java.util.concurrent.atomic.AtomicInteger;

public class VolatileCounter {
    // 用volatile保证可见性
    private volatile int count = 0;

    public void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }
}

上面的count变量用volatile修饰，每次读写都有完整屏障。如果用VarHandle的Acquire/Release语义替代，代码如下：

import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;

public class VarHandleCounter {
    private int count = 0;
    // 获取count变量的VarHandle
    private static final VarHandle COUNT_HANDLE;

    static {
        try {
            COUNT_HANDLE = MethodHandles.lookup()
                    .findVarHandle(VarHandleCounter.class, "count", int.class);
        } catch (Exception e) {
            throw new Error(e);
        }
    }

    public void increment() {
        // 用Release语义写，保证写之前的操作不会被重排序，且结果对其他线程Acquire读可见
        int oldValue;
        do {
            oldValue = (int) COUNT_HANDLE.acquireRead(this); // Acquire读获取当前值
        } while (!COUNT_HANDLE.releaseCompareAndSet(this, oldValue, oldValue + 1)); // Release写更新值
    }

    public int getCount() {
        // 用Acquire读，保证读之后的操作不会被重排序，且能读到最新的Release写结果
        return (int) COUNT_HANDLE.acquireRead(this);
    }
}

上面的代码中，acquireRead对应Acquire语义的读操作，releaseCompareAndSet的写部分对应Release语义的写操作，只在需要的操作上施加了对应的屏障，比volatile的全量屏障更轻量。

更细粒度的场景示例

假设我们有一个状态变量和一个数据变量，状态变量标记数据是否就绪，数据变量存储实际内容。用volatile实现的话，两个变量都会被施加全量屏障，而用VarHandle可以只给状态变量的写加Release语义，给状态变量的读加Acquire语义，数据变量的读写不需要额外屏障：

import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;

public class DataContainer {
    private String data;
    private int state = 0; // 0表示未就绪，1表示就绪

    private static final VarHandle STATE_HANDLE;
    private static final VarHandle DATA_HANDLE;

    static {
        try {
            STATE_HANDLE = MethodHandles.lookup()
                    .findVarHandle(DataContainer.class, "state", int.class);
            DATA_HANDLE = MethodHandles.lookup()
                    .findVarHandle(DataContainer.class, "data", String.class);
        } catch (Exception e) {
            throw new Error(e);
        }
    }

    // 写线程调用，写入数据后更新状态
    public void writeData(String newData) {
        DATA_HANDLE.set(this, newData); // 普通写，不需要屏障
        // Release写状态，保证data的普通写不会被重排序到state写之后，且state的更新对其他线程Acquire读可见
        STATE_HANDLE.releaseWrite(this, 1);
    }

    // 读线程调用，先检查状态再读数据
    public String readData() {
        // Acquire读状态，保证后续读data的操作不会被重排序到state读之前，且能读到最新的Release写结果
        int currentState = (int) STATE_HANDLE.acquireRead(this);
        if (currentState == 1) {
            return (String) DATA_HANDLE.get(this); // 普通读，不需要屏障
        }
        return null;
    }
}

在这个例子中，只有state的写用了Release语义，state的读用了Acquire语义，data的读写都是普通操作，没有额外的内存屏障，既保证了当state被读线程看到为1时，data的写入一定已经完成，又减少了不必要的屏障开销，实现了比volatile更细粒度的控制。

注意事项

• VarHandle是Java 9及以上版本才引入的API，低版本Java无法使用。
• Acquire/Release语义的适用范围比volatile窄，只保证配对的操作之间的可见性，不适合所有需要内存可见性的场景，需要根据实际需求选择。
• 使用VarHandle操作变量时，要确保变量的访问权限正确，静态变量和实例变量的VarHandle获取方式略有不同。

Variable_HandlesAcquire/Release语义volatile内存可见性Java并发修改时间：2026-07-18 12:06:35