Java MemorySegment 切片越界怎么检查

Java 的 MemorySegment.asSlice(offset, newSize) 会在创建切片时检查空间边界。最稳妥的预检查不是计算 offset + newSize，而是分别确认两个参数非负、offset ，再判断 newSize 。这样既符合 API 的异常条件，也不会被 long 加法溢出绕过。

我在给二进制解析器封装切片接口时，最容易犯的错不是忘记检查，而是把数组思维直接搬过来：把元素下标当成字节偏移，或者先做 offset + length 再与总长度比较。MemorySegment 的参数单位是字节，调用方契约如果不先说清楚，错误常常会被拖到后续读取才暴露。

官方文档：https://docs.oracle.com/en/java/javase/26/docs/api/java.base/java/lang/foreign/MemorySegment.html

先把调用方需要的切片契约说清楚

asSlice(long offset, long newSize) 返回一个共享原有内存区域的新视图，不会复制底层数据。新切片的起始地址是在原段地址上加字节偏移，切片大小由 newSize 指定。它的空间边界比父段更严格。

按照当前 Java SE 文档，下面四类输入会触发 IndexOutOfBoundsException：

• offset ；
• offset > segment.byteSize()；
• newSize ；
• newSize > segment.byteSize() - offset。

这里有两个很实用的边界：offset == byteSize() 且 newSize == 0 是合法的尾部空切片；只要 newSize > 0，同一个尾部偏移就越界。空段不是错误，它很适合表达“输入已经消费完”。

用 byteSize() - offset 做无溢出检查

如果直接写 offset + newSize ，两个很大的正数可能在 long 中溢出为负数。更安全的写法先把 offset 限定到父段内，再用减法得到剩余空间。

import java.lang.foreign.MemorySegment;

static boolean rangeFits(MemorySegment segment, long offset, long newSize) {
    // 先排除负数，保证后面的减法语义稳定
    if (offset  total) {
        return false;
    }

    // 不计算 offset + newSize，避免 long 加法溢出
    return newSize 

这个判断和 asSlice 的空间异常模型是一致的。对我来说，它还有一个接口设计上的好处：调用方可以在真正创建视图前得到布尔判断，而不是把异常当成普通分支。

为不同调用方设计两种错误模型

公共工具方法不一定都要照搬 JDK 的异常。如果边界不合法是可预期输入，例如网络帧可能被截断，我更倾向返回 Optional；如果调用方传入的偏移代表程序内部协议，越界说明代码或数据契约已经坏掉，则应抛出带参数的业务异常。

import java.lang.foreign.MemorySegment;
import java.util.Optional;

final class SegmentSlices {
    private SegmentSlices() {
        // 工具类不需要实例化
    }

    static Optional trySlice(
            MemorySegment segment, long offset, long newSize) {
        // 可预期的短数据使用 Optional 表达，而不是依赖异常控制流程
        if (!rangeFits(segment, offset, newSize)) {
            return Optional.empty();
        }
        return Optional.of(segment.asSlice(offset, newSize));
    }

    static MemorySegment requireSlice(
            MemorySegment segment, long offset, long newSize) {
        // 内部协议错误要保留总长度和请求范围，便于定位上游参数
        if (!rangeFits(segment, offset, newSize)) {
            throw new IllegalArgumentException(
                    "invalid slice: offset=" + offset
                            + ", size=" + newSize
                            + ", segmentSize=" + segment.byteSize());
        }
        return segment.asSlice(offset, newSize);
    }

    private static boolean rangeFits(
            MemorySegment segment, long offset, long newSize) {
        // 先限定 offset，再使用 total - offset，避免加法溢出
        long total = segment.byteSize();
        return offset >= 0
                && newSize >= 0
                && offset 

我不会在这里捕获所有 RuntimeException 后统一返回空值。那会把对齐错误、Arena 已关闭、线程访问限制等不同问题全部伪装成“长度不够”，调用方也就失去了正确修复方向。

元素下标要先换算成字节范围

offset 和 newSize 都是字节数，不是第几个元素。如果上层接口接收元素下标与元素数量，换算时还要防止乘法溢出。Math.multiplyExact 能让溢出立即变成明确异常。

import java.lang.foreign.MemoryLayout;
import java.lang.foreign.MemorySegment;

static MemorySegment sliceElements(
        MemorySegment segment,
        long elementIndex,
        long elementCount,
        MemoryLayout elementLayout) {

    // 元素坐标先安全换算为字节坐标，溢出时直接拒绝
    long offset = Math.multiplyExact(elementIndex, elementLayout.byteSize());
    long newSize = Math.multiplyExact(elementCount, elementLayout.byteSize());

    // 复用字节范围检查，不把元素单位混入底层切片接口
    if (!rangeFits(segment, offset, newSize)) {
        throw new IllegalArgumentException("element range exceeds segment");
    }
    return segment.asSlice(offset, newSize);
}

如果切片本身就对应一个固定结构，优先考虑 asSlice(offset, layout)。这个重载把切片大小固定为 layout.byteSize()，同时带入布局的对齐约束，比调用方分别传偏移和长度更不容易写错。

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

static final MemoryLayout HEADER = MemoryLayout.structLayout(
        ValueLayout.JAVA_INT.withName("type"),
        ValueLayout.JAVA_INT.withName("payloadLength")
);

static MemorySegment headerSlice(MemorySegment segment, long offset) {
    // layout 重载同时表达固定大小与对齐要求
    return segment.asSlice(offset, HEADER);
}

创建成功后，读取仍受切片自身边界限制

切片创建成功只证明请求的视图落在父段内，并不代表后续任意读取都安全。访问操作使用的是切片自己的 byteSize()。例如一个 16 字节切片，从偏移 12 读取 8 字节 long 仍然越界，因为访问末端超过了 16。

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

static long readLong(MemorySegment slice, long offset) {
    long width = ValueLayout.JAVA_LONG.byteSize();
    // 读取也使用“剩余空间”判断，不能只检查起始偏移
    if (offset  slice.byteSize()
            || width > slice.byteSize() - offset) {
        throw new IllegalArgumentException("long value exceeds slice");
    }

    // 通过空间检查后，JDK 仍会执行布局对齐与生命周期检查
    return slice.get(ValueLayout.JAVA_LONG, offset);
}

这也是我更愿意把切片继续传给下游，而不是把父段和原始绝对偏移一起传递的原因：更窄的空间边界就是更清楚的 API 契约，下游只能看见它该访问的那一段。

不要把所有异常都当成切片越界

MemorySegment 同时有空间边界、布局约束和生命周期。三类问题可能出现在相邻代码里，但异常类型和修复方式不同。

切片继承父段的时间边界。用 Arena 分配原生段时，即使切片对象仍然可达，Arena 关闭后也不能继续访问。延长切片长度或重新计算 offset 都解决不了生命周期错误。

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

static MemorySegment temporarySlice() {
    try (Arena arena = Arena.ofConfined()) {
        MemorySegment segment = arena.allocate(64);
        // 切片共享父段的内存区域与生命周期，不会独立保活
        return segment.asSlice(8, 16);
    }
    // 返回值离开这里时 Arena 已关闭，调用方不能再访问该切片
}

上面的写法故意展示了一个不应采用的接口：它返回了一个已经失效的切片。更合理的设计是在 try 范围内完成解析，或者让持有 Arena 的上层组件同时管理切片的使用期。

我现在使用的判断顺序

1. 先确认上层参数的单位：字节还是元素；如果是元素，使用 Math.multiplyExact 换算。
2. 拒绝负的 offset 与 newSize。
3. 确认 offset 。
4. 用 newSize 判断剩余空间，不做加法。
5. 固定结构优先传 MemoryLayout，让大小和对齐成为同一个契约。
6. 切片创建后，读取和写入继续按切片自身的边界检查。
7. 根据异常类型分别检查空间、对齐和 Arena 生命周期。

这套顺序的核心不是“提前复制一遍 JDK 检查”，而是让调用方在进入底层 API 前就拥有稳定、可读的错误模型。对于内部不变量，可以直接让 asSlice 抛异常；对于外部不可信长度，先检查并返回 Optional 或领域错误会更友好。

常见问题

offset 等于 byteSize() 一定越界吗？

不一定。此时只有 newSize == 0 合法，任何正长度切片都会超过父段末尾。

可以只捕获 IndexOutOfBoundsException 吗？

如果你的接口把越界视为异常，可以直接依赖 JDK 抛出的 IndexOutOfBoundsException。但外部数据解析通常需要更清楚的错误信息，建议在调用前记录 offset、请求长度和父段总长度。不要捕获所有运行时异常后统一改成越界。

asSlice(offset) 和 asSlice(offset, newSize) 有什么区别？

单参数重载会把切片长度设为 byteSize() - offset，适合从某个字节位置一直看到父段末尾；双参数重载显式限制长度，更适合协议字段、固定块和下游最小权限视图。

切片会复制内存吗？

不会。切片与父段共享同一块底层内存区域，因此写入可见性、只读属性和生命周期都要按共享视图理解。

最终可以把规则压缩成一句话：先保证 offset 在父段内，再用 byteSize() - offset 约束长度；元素坐标先安全换算成字节，布局和生命周期错误则单独处理。