NativeContainer 内存安全机制：Dispose 泄漏与多线程并发冲突治理

NativeContainer 内存安全机制：Dispose 泄漏与多线程并发冲突治理

Unity 的 C# Job System 允许开发者安全地编写多线程并行代码，其基石是 NativeContainer 集合家族（如 NativeArray<T>、NativeList<T>、NativeHashMap<K, V>）。这些容器直接分配在非托管堆（Native Heap）上，完全规避了托管堆垃圾回收（GC）的停顿，同时通过底层的安全句柄机制，在编译期和运行期强行阻止了多线程数据竞争（Race Conditions）与内存野指针访问。

理解 AtomicSafetyHandle 的工作机制，并建立健壮的生命周期管理，是驾驭高性能 DOTS 架构的前提。

AtomicSafetyHandle：运行时线程冲突检测机制

在开启 Unity Editor 或 Development Build 时，每个 NativeContainer 内部都封装了一个 AtomicSafetyHandle。它的本质是一个 64 位的原子整数状态字，跟踪容器的读写版本号、所属线程以及活跃 Job 的依赖关系。

NativeArray<T> 内部结构 (Debug 模式):
┌───────────────────────────────────────────────┐
│ void* m_Buffer (指向非托管堆的连续内存指针) │
│ int m_Length │
│ Allocator m_AllocatorLabel │
│ AtomicSafetyHandle m_Safety (线程与读写安全句柄) │
└───────────────────────────────────────────────┘

读写锁与并发冲突规则

using Unity.Burst;
using Unity.Collections;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Jobs;
using UnityEngine;

public class NativeSafetyDemonstration : MonoBehaviour
{
private struct BadParallelWriteJob : IJobParallelFor
{
public NativeArray<int> Output;
public void Execute(int index)
{
// 多个线程并发写入同一个固定槽位 0 -> 触发数据竞争
Output[0] += index;
}
}

private void RunConcurrenctCheck()
{
NativeArray<int> data = new NativeArray<int>(100, Allocator.TempJob);

var job = new BadParallelWriteJob { Output = data };
// IJobParallelFor 要求每个线程通过 index 隔离访问，安全系统会自动校验
JobHandle handle = job.Schedule(100, 64);

// 若在 Complete 之前主线程直接读取：
// int value = data[0]; // 立即抛出 InvalidOperationException

handle.Complete();
data.Dispose();
}
}

Dispose 泄漏追踪与排查体系

NativeContainer 不受托管垃圾回收器管理。如果一个在 Allocator.Persistent 下分配的 NativeArray 丢失了所有托管引用而未调用 .Dispose()，对应的非托管内存将永久滞留在操作系统的物理内存中，形成实质性的 Native 内存泄漏。

内存泄漏检测级别配置

在 Unity Editor 菜单中，可设置 Jobs -> Leak Detection Level：

[Native Leak Detected]
Allocated at:
at Unity.Collections.NativeArray`1..ctor (Int32 length, Allocator allocator) [0x00012]
at GameBattleSystem.InitializeEnemySpawners () [0x00045] in /Scripts/GameBattleSystem.cs:88

RAII 与 JobHandle 自动释放模式

为了杜绝手动调用 Dispose() 时的遗漏，Unity 提供了无缝衔接 Job 生命周期的自动释放语法：

public class SafeJobPipeline
{
[BurstCompile]
private struct ComputeWaveJob : IJob
{
[ReadOnly] public NativeArray<float> Inputs;
public NativeArray<float> Outputs;

public void Execute()
{
for (int i = 0; i < Inputs.Length; i++)
{
Outputs[i] = Mathf.Sin(Inputs[i]);
}
}
}

public void ExecutePipeline()
{
// 使用 TempJob 分配临时生命周期
NativeArray<float> inputs = new NativeArray<float>(1024, Allocator.TempJob);
NativeArray<float> outputs = new NativeArray<float>(1024, Allocator.TempJob);

// 填充数据
for (int i = 0; i < 1024; i++) inputs[i] = i * 0.1f;

ComputeWaveJob job = new ComputeWaveJob
{
Inputs = inputs,
Outputs = outputs
};

JobHandle handle = job.Schedule();

// 关键点：将 Dispose 挂载到 JobHandle 的完成事件上
// Job 执行完毕后，工作线程或主线程会自动无感释放内存，无需手动等待
inputs.Dispose(handle);
outputs.Dispose(handle);

// 主线程可继续执行其他业务…
}
}

危险特权特性的安全边界

在追求极限性能的高级开发中，有时默认的安全检查会阻碍合法的算法结构（例如多线程并发原子写入、无锁环形队列）。Unity 提供了特权属性：

• [NativeDisableUnsafePtrRestriction]：允许在 Job 内部传递原始非托管指针（void* 或 T*）。
• [NativeDisableParallelForRestriction]：允许在 IJobParallelFor 中自由访问非当前 index 槽位的数据。
• [NativeDisableContainerSafetyRestriction]：彻底剥离容器的 AtomicSafetyHandle 校验。

使用这些特权属性时，必须通过 Interlocked 原子指令或硬件屏障严格保证并发安全：

[BurstCompile]
public struct ParallelHistogramJob : IJobParallelFor
{
[ReadOnly] public NativeArray<int> InputData;

// 显式声明绕过并行写入限制
[NativeDisableParallelForRestriction]
public NativeArray<int> HistogramBuckets;

public unsafe void Execute(int index)
{
int val = InputData[index];
int bucketIndex = val % HistogramBuckets.Length;

// 必须使用原生原子累加指令，否则会导致严重的并发数据丢失
int* bucketPtr = (int*)HistogramBuckets.GetUnsafePtr();
System.Threading.Interlocked.Increment(ref bucketPtr[bucketIndex]);
}
}

在架构设计中，应当始终遵循“在 Debug/Editor 环境下依赖 AtomicSafetyHandle 建立绝对的安全断言，在 Release/Burst 编译中彻底剥离安全句柄以获得零开销的原生执行性能”这一工业化标准。