Why does NativeList resize throw inside a parallel job?

NativeList isn't safe for concurrent resize. Use AsParallelWriter to append from multiple threads via AddNoResize. Pre-size capacity to avoid resize during job.

AsParallelWriter limits?

Caller pre-sizes via SetCapacity. AddNoResize is lock-free; failure if capacity exceeded. Plan max count up front.

After job completes, the writer's count reflects appends. List.length is updated automatically. Resize main-thread for next round.

Fix: NativeList Resize Across Jobs Throws

Quick answer: Pre-size NativeList capacity. In job: list.AsParallelWriter().AddNoResize(item). Resize main-thread between jobs.

IJobParallelFor appends results to a shared NativeList. Throws because resize isn't thread-safe.

The Fix

var results = new NativeList<int>(Allocator.TempJob);
results.SetCapacity(maxExpected);   // pre-size

struct FilterJob : IJobParallelFor {
    [ReadOnly] public NativeArray<int> In;
    public NativeList<int>.ParallelWriter Out;
    public void Execute(int i) {
        if (In[i] > 10) Out.AddNoResize(In[i]);
    }
}

var handle = new FilterJob { In = data, Out = results.AsParallelWriter() }.Schedule(data.Length, 64);
handle.Complete();

Pre-sized capacity + AddNoResize is lock-free. List length grows as appends succeed.

Verifying

Job completes. results.Length matches expected. Without ParallelWriter: throw on parallel add.

“Pre-size. ParallelWriter. Lock-free.”

Related Issues

For NativeArray dispose, see dispose. For ReadOnly write, see readonly.

Pre-size. ParallelWriter. Append.