Unity使用IJobParallelFor优化性能出现IndexOutOfRangeException报错如何解决

报错根因分析 #

System.IndexOutOfRangeException: Index {0} is out of restricted IJobParallelFor range [{1}...{2}] in ReadWriteBuffer.
这个报错的核心诱因有2个，你加的[NativeDisableParallelForRestriction]等属性没用是因为本身代码存在逻辑错误和数据竞争问题，不是单纯的安全校验限制：

1. 邻居索引计算错误：你写的3D偏移转1D索引的公式完全错误，导致neigbourIndex超出了neighboursArray的数组长度，直接触发索引越界。
2. 共享容器并行写入冲突：neighboursArray、voxelToColor是所有Job线程共享的可写容器，IJobParallelFor默认限制每个线程只能写入和当前执行index对应的容器位置，你所有线程都任意写入容器的任意下标，即使关掉安全校验也会出现数据覆盖、逻辑错误的问题。

修复步骤 #

1. 修复邻居索引计算逻辑 #

你的3x3x3（kernelSize=3的场景）偏移转1下标的公式错误，正确的转换逻辑为：

// 三个循环变量i、j、k对应x、y、z轴偏移，偏移范围都是[0, kernelSize-1]
int offsetX = i + 1;
int offsetY = j + 1;
int offsetZ = k + 1;
int neigbourIndex = offsetX * kernelSize * kernelSize + offsetY * kernelSize + offsetZ;

同时要加边界校验，确保neigbourIndex < neighboursArray.Length，避免越界。

2. 移除共享写入的临时容器 #

neighboursArray完全不需要作为Job的公共字段，它只是每个Execute执行时的临时存储容器，直接改成栈内分配的固定数组即可，完全避开多线程写入冲突：

// 在Execute方法内直接声明，不需要作为公共NativeArray传进来
// kernelSize最大不会超过32的话，用stackalloc分配完全够用，不需要堆内存
Span<int> neighboursArray = stackalloc int[kernelSize * kernelSize * kernelSize];

3. 修复voxelToColor的写入逻辑 #

你现在每个Execute线程都从listIndex=0开始写voxelToColor，多个线程会写同一个下标导致数据覆盖。如果你的需求是收集所有符合条件的index，有两种方案：

• 方案1：如果每个index对应固定大小的写入位置，把voxelToColor的长度设为总任务数 * 单任务最大写入数，每个线程写入的起始下标为index * 单任务最大写入数，避免下标冲突。
• 方案2：如果需要动态收集，改用NativeQueue<int>作为输出容器，用Enqueue方法写入，天然支持多线程并行写入。

4. 可选：保留安全属性的场景 #

如果确实需要跨index写入共享容器，在确认没有数据竞争的前提下，需要把属性加在对应的容器字段上，而不是加在结构体上，示例：

[NativeDisableParallelForRestriction]
public NativeArray<int> voxelToColor;

完整参考代码 #

[BurstCompile(CompileSynchronously = true)]
public struct DilationJob : IJobParallelFor
{
    [ReadOnly] public NativeArray<Color32> colorsArray;
    public NativeQueue<int>.ParallelWriter voxelToColorWriter; // 改用NativeQueue并行写入器
    public int kernelSize;
    public int cubeNumber;
    
    public void Execute(int index)
    {   
        const int dimx = 512;
        const int dimy = 512; 
        
        // 临时邻居数组用stackalloc分配，每个线程独立，无冲突
        Span<int> neighboursArray = stackalloc int[kernelSize * kernelSize * kernelSize];
        
        for (int i = -1; i < kernelSize - 1; i++)
        {
            for (int j = -1; j < kernelSize - 1; j++)
            {
                for (int k = -1; k < kernelSize - 1; k++)
                {
                    int offsetX = i + 1;
                    int offsetY = j + 1;
                    int offsetZ = k + 1;
                    int neigbourIndex = offsetX * kernelSize * kernelSize + offsetY * kernelSize + offsetZ;
                    
                    // 加边界校验避免越界
                    if (neigbourIndex < 0 || neigbourIndex >= neighboursArray.Length)
                        continue;

                    int neighbourVoxelIndex = index + k * dimx * dimy + j * dimx + i;
                    neighboursArray[neigbourIndex] = neighbourVoxelIndex;

                    if (neighbourVoxelIndex >=0 && neighbourVoxelIndex < colorsArray.Length 
                        && colorsArray[neighbourVoxelIndex].b == 255)
                    {
                        // 用ParallelWriter写入，线程安全
                        voxelToColorWriter.Enqueue(index);
                    }
                }
            }
        }
    }
}

使用时提前初始化NativeQueue，传入voxelToColorWriter = queue.AsParallelWriter()即可。

内容的提问来源于stack exchange，提问作者SunriseAvenue