Java MemorySegment 怎么限制跨线程访问范围

Java MemorySegment 不能在创建后单独设置“允许哪些线程访问”。线程可访问范围由它关联的 Arena 决定：Arena.ofConfined() 创建的段只能由 Arena 的所有者线程访问；Arena.ofShared() 创建的段可以被任意线程访问。错误线程读写 confined 段时会抛出 WrongThreadException。

官方地址：https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/lang/foreign/Arena.html

JDK 22 之后先看 Arena，而不是给 Segment 加锁

JEP 454 在 JDK 22 把 Foreign Function & Memory API 定稿为 java.lang.foreign。迁移旧的预览 API 时，线程边界应直接落到 Arena 选择上。官方 API 给出的四类 Arena 具有不同组合：

segment.isAccessibleBy(thread) 可以查询给定线程是否有权访问，但它只是检查，不会改变权限。段的 scope() 还决定生命周期：Arena 关闭后，相关 MemorySegment 即使仍有 Java 引用也不能继续访问。

最小限制写法：让分配和访问留在所有者线程

如果数据只属于一个任务，最小写法是在线程内部创建 confined Arena。这样线程归属与内存生命周期同时被 API 固定下来：

import java.lang.foreign.Arena;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.ValueLayout;

public class ConfinedSegmentDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread worker = Thread.startVirtualThread(() -> {
            // Arena 在当前虚拟线程创建，因此该线程就是唯一所有者。
            try (Arena arena = Arena.ofConfined()) {
                MemorySegment segment = arena.allocate(ValueLayout.JAVA_INT);

                // 读写都发生在所有者线程内，关闭后内存立即失效。
                segment.set(ValueLayout.JAVA_INT, 0, 42);
                int value = segment.get(ValueLayout.JAVA_INT, 0);
                System.out.println(value);
            }
        });

        // 等待任务结束，避免主线程提前退出。
        worker.join();
    }
}

这比“把 segment 传给线程池，再靠约定不访问”更可靠。只要其他线程实际执行 get、set、copy 等受检查操作，就会触发 WrongThreadException。从非所有者线程关闭 confined Arena 同样会失败。

旧代码跨线程时要迁移为 shared Arena

如果旧代码确实需要多个线程访问同一段内存，不能先用 confined Arena 分配，再把引用交给线程池。应在资源创建处明确改为 Arena.ofShared()，同时补上并发策略：

import java.lang.foreign.Arena;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.ValueLayout;
import java.util.concurrent.Executors;

public class SharedSegmentDemo {
    public static void main(String[] args) throws Exception {
        // shared Arena 允许线程池任务访问，资源仍由 try-with-resources 确定关闭。
        try (Arena arena = Arena.ofShared();
             var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            MemorySegment segment = arena.allocate(ValueLayout.JAVA_INT);

            var write = executor.submit(() -> {
                // 示例只有一个写任务；多个并发写任务仍需要同步或数据分区。
                segment.set(ValueLayout.JAVA_INT, 0, 7);
            });
            write.get();

            var read = executor.submit(() -> {
                // 读取发生在另一线程，shared Arena 允许该访问。
                return segment.get(ValueLayout.JAVA_INT, 0);
            });
            System.out.println(read.get());
        }
    }
}

这里的迁移只解决“线程有没有资格访问”。如果两个线程同时写同一地址，仍然可能发生数据竞争；MemorySegment 不会自动替应用加锁，也不会替业务定义写入顺序。

切片只能限制空间范围

asSlice(offset, size) 可以把父段拆成互不重叠的字节区间，适合把不同数据块交给并行任务。切片继承同一个 scope，因此也继承原 Arena 的线程访问规则。shared 父段的 slice 仍可被任意线程访问，confined 父段的 slice 仍只能由所有者线程访问。

import java.lang.foreign.Arena;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.ValueLayout;

public final class SegmentPartitions {
    static MemorySegment[] split(Arena arena) {
        // 分配 8 个 int 的连续区域，并按空间范围平均切成两段。
        long intBytes = ValueLayout.JAVA_INT.byteSize();
        MemorySegment parent = arena.allocate(intBytes * 8, ValueLayout.JAVA_INT.byteAlignment());

        // 两个 slice 不重叠，便于把写入任务按数据区间拆分。
        MemorySegment left = parent.asSlice(0, intBytes * 4);
        MemorySegment right = parent.asSlice(intBytes * 4, intBytes * 4);
        return new MemorySegment[] {left, right};
    }
}

只读视图 asReadOnly() 也不是线程白名单。它阻止写操作，但不改变哪些线程能够读取。真正要限制线程身份时使用 confined Arena；真正要限制字节区域时使用 slice；真正要协调 shared 内存的并发写入时使用锁、原子访问策略或互不重叠的任务分区。

异常类型能快速判断边界错在哪里

这几类检查彼此独立。把 segment 改为 shared 只能消除线程归属冲突，不会修复关闭后的访问、空间越界、对齐错误或并发竞态。

迁移与回归检查清单

• 确认项目使用 JDK 22 或更高版本的 java.lang.foreign 最终 API。
• 逐个标记 MemorySegment 是任务私有还是跨线程共享，不要默认全部改成 shared。
• 任务私有数据在工作线程内部创建 ofConfined()，避免把段或 Arena 逃逸到外部。
• 共享数据用 ofShared()，并单独设计同步、原子访问或不重叠分片。
• 关闭 Arena 前等待所有访问任务完成；不要让异步任务越过资源作用域。
• 测试错误线程访问、Arena 关闭后访问、slice 越界和两个任务写同一区域。

相关问题

MemorySegment.asSlice 能限制某个线程只能访问一段吗？

不能。slice 只缩小空间边界，线程可访问性仍来自同一个 Arena scope。

Arena.ofAuto 适合跨线程共享吗？

它创建的段可被任意线程访问，但生命周期由垃圾收集器管理，不能显式关闭。需要确定释放时机时，通常应选择 shared Arena。

shared Arena 会自动保证写入线程安全吗？

不会。它保证多个线程有访问资格，并提供安全的生命周期语义；同一地址上的业务并发仍需要应用协调。

怎么在访问前判断当前线程是否可用？

调用 segment.isAccessibleBy(Thread.currentThread()) 可以查询，但它不能替代正确的 Arena 设计，也不能避免检查后 Arena 被其他线程关闭所产生的生命周期变化。