为什么我传递给多线程作业结构的数组充当引用类型？

如何解决为什么我传递给多线程作业结构的数组充当引用类型？

我正在开发一个基于行进立方体的可变形地形的统一项目。它的工作原理是在地形块的 3 维坐标上生成密度图，并使用该数据创建表示地形表面的网格。它一直在工作，但是过程非常缓慢。我正在尝试引入多线程来提高性能，但遇到了一个让我摸不着头脑的问题。

当我运行 CreateMeshData() 并尝试将我的密度图 terrainMap 传递到 marchCubeJob 结构时，它会将其识别为引用类型，不是值类型。我似乎将错误减少到这个错误，但我试图以我知道的各种方式引入数据，但我被难住了。我认为传递这样的引用应该创建一个与引用断开连接的数据副本，但我的理解一定是有缺陷的。我的目标是将每个 marchingcube 多维数据集传递给一个作业并让它们同时运行。

我是多线程的新手，所以我可能在这里犯了一些新手错误，如果有人能帮我再看一眼，我将不胜感激。干杯！

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Unity.Jobs;
using Unity.Collections;
using Unity.Burst;

public class Chunk
{

    List<Vector3> vertices = new List<Vector3>();
    List<int> triangles = new List<int>();

    public GameObject chunkObject;
    MeshFilter meshFilter;
    MeshCollider meshCollider;
    MeshRenderer meshRenderer;

    Vector3Int chunkPosition;

    public float[,] terrainMap;
    
    // Job system
    NativeList<Vector3> marchVerts;
    NativeList<Vector3> marchTris;
    marchCubeJob instancemarchCube;
    JobHandle instanceJobHandle;


    int width { get { return Terrain_Data.chunkWidth;}}
    int height { get { return Terrain_Data.chunkHeight;}}
    static float terrainSurface { get { return Terrain_Data.terrainSurface;}}

    public Chunk (Vector3Int _position){ // Constructor

        chunkObject = new GameObject();
        chunkObject.name = string.Format("Chunk x{0},y{1},z{2}",_position.x,_position.y,_position.z);
        chunkPosition = _position;
        chunkObject.transform.position = chunkPosition;
        meshRenderer = chunkObject.AddComponent<MeshRenderer>();
        meshFilter = chunkObject.AddComponent<MeshFilter>();
        meshCollider = chunkObject.AddComponent<MeshCollider>();
        chunkObject.transform.tag = "Terrain";
        terrainMap = new float[width + 1,height + 1,width + 1]; // Weight of each point
        meshRenderer.material = Resources.Load<Material>("Materials/Terrain");
        
        // Generate chunk
        PopulateTerrainMap();
        CreateMeshData();
    }

    void PopulateTerrainMap(){
        ...
    }

    void CreateMeshData(){

        ClearMeshData();

        vertices = new List<Vector3>();

        for (int x = 0; x < width; x++) {
            for (int y = 0; y < height; y++) {
                for (int z = 0; z < width; z++) {

                    Debug.Log(x + "," + y + "," + z + ",begin");

                    Vector3Int position = new Vector3Int(x,y,z);

                    // Set up memory pointers
                    NativeList<Vector3> marchVerts = new NativeList<Vector3>(Allocator.TempJob);
                    NativeList<int> marchTris = new NativeList<int>(Allocator.TempJob);
                    NativeList<float> mapSample = new NativeList<float>(Allocator.TempJob);

                    // Split marchcube into jobs by cube
                    instancemarchCube = new marchCubeJob(){
                        position = position,marchVerts = marchVerts,marchTris = marchTris,mapSample = terrainMap
                    };

                    // Run job for each cube in a chunk
                    instanceJobHandle = instancemarchCube.Schedule();
                    instanceJobHandle.Complete();

                    // copy data from job to mesh data
                    //instancemarchCube.marchVerts.copyTo(vertices);
                    vertices.AddRange(marchVerts);
                    triangles.AddRange(marchTris);

                    // dispose of memory pointers
                    marchVerts.dispose();
                    marchTris.dispose();
                    mapSample.dispose();

                    Debug.Log(x + ",end");
                }
            }
        }

        BuildMesh();

    }

    public void PlaceTerrain (Vector3 pos,int radius,float speed){

        ...

        CreateMeshData();

    }

    public void RemoveTerrain (Vector3 pos,float speed){

        ...

        CreateMeshData();

    }

    void ClearMeshData(){

        vertices.Clear();
        triangles.Clear();

    }

    void BuildMesh(){

        Mesh mesh = new Mesh();
        mesh.vertices = vertices.ToArray();
        mesh.triangles = triangles.ToArray();
        mesh.Recalculatenormals();
        meshFilter.mesh = mesh;
        meshCollider.sharedMesh = mesh;

    }

    private void OnDestroy(){
        marchVerts.dispose();
        marchTris.dispose();
    }

}

// Build a cube as a job
[BurstCompile]
public struct marchCubeJob: IJob{

    static float terrainSurface { get { return Terrain_Data.terrainSurface;}}

    public Vector3Int position;

    public NativeList<Vector3> marchVerts;
    public NativeList<int> marchTris;
    public float[,] mapSample;

    public void Execute(){

        //Sample terrain values at each corner of cube
        float[] cube = new float[8];
        for (int i = 0; i < 8; i++){

            cube[i] = SampleTerrain(position + Terrain_Data.CornerTable[i]);

        }

        int configIndex = GetCubeConfiguration(cube);

        // If done (-1 means there are no more vertices)
        if (configIndex == 0 || configIndex == 255){
            return;
        }

        int edgeIndex = 0;
        for (int i = 0; i < 5; i++){ // Triangles
            for (int p = 0; p < 3; p++){ // Tri Vertices

                int indice = Terrain_Data.TriangleTable[configIndex,edgeIndex];

                if (indice == -1){
                    return;
                }

                // Get 2 points of edge
                Vector3 vert1 = position + Terrain_Data.CornerTable[Terrain_Data.EdgeIndexes[indice,0]];
                Vector3 vert2 = position + Terrain_Data.CornerTable[Terrain_Data.EdgeIndexes[indice,1]];

                Vector3 vertPosition;

                
                // Smooth terrain
                // Sample terrain values at either end of current edge
                float vert1Sample = cube[Terrain_Data.EdgeIndexes[indice,0]];
                float vert2Sample = cube[Terrain_Data.EdgeIndexes[indice,1]];

                // Calculate difference between terrain values
                float difference = vert2Sample - vert1Sample;


                if (difference == 0){
                    difference = terrainSurface;
                }
                else{
                    difference = (terrainSurface - vert1Sample) / difference;
                }

                vertPosition = vert1 + ((vert2 - vert1) * difference);



                marchVerts.Add(vertPosition);
                marchTris.Add(marchVerts.Length - 1);
                edgeIndex++;
            }
        }
    }

    static int GetCubeConfiguration(float[] cube){

        int configurationIndex = 0;
        for (int i = 0; i < 8; i++){

            if (cube[i] > terrainSurface){
                configurationIndex |= 1 << i;
            }

        }

        return configurationIndex;

    }

    public float SampleTerrain(Vector3Int point){

        return mapSample[point.x,point.y,point.z];

    }

}