Threading large jobs

Ok.
Right now I have a procedural land system based on a quad seem system for LOD handling. Everything works. Except that it constantly needs updates depending on range and state of change. So Iv implemented a threading system to try to offload as much data of what should be available never has to be finished the same frame it was called for.

Yes, I know ESC and the Job system is here for early testing. And kind of tried it to. But, I feel some of the issues when can be pretty hard when dealing custom built meshes for game objects that needs to be up to date most of the time for example.

So, Iv made a threading system that calculates and processes everything that is needed, then makes a callback to the main thread as we know not everything can be done in a separate thread. However, this makes some heavy performance spikes show up. And if I inspect it in the profiler it looks like it dose threaded like it should, but it finishes the job in the same frame. This is not needed, it can finish 2-10 frames in the future if needed. So Im trying to understand why this is happening.

This is my threaded manager of the quads

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4. using System;
5. using System.Threading;
6. using System.Threading.Tasks;
7.  
8. public class ThreadedQuadRequester : MonoBehaviour
9. {
10.     static ThreadedQuadRequester instance;
11.     Queue<ThreadData> dataQueue = new Queue<ThreadData>();
12.     static Thread unityThread;
13.      
14.     void Awake()
15.     {      
16.         instance = FindObjectOfType<ThreadedQuadRequester>();
17.         unityThread = Thread.CurrentThread;
18.     }
19.  
20.     public static void RequestData(Func<object> function, Action<object> funcCallback)
21.     {
22.         ThreadStart threadStart = delegate {
23.             instance.DataThread(function, funcCallback);
24.         };            
25.  
26.         Thread thread = GetThread(threadStart);
27.         thread.Priority = System.Threading.ThreadPriority.Lowest;
28.         thread.IsBackground = true;      
29.         thread.Start();
30.     }
31.  
32.     static Thread GetThread(ThreadStart threadStart)
33.     {
34.         Thread thread = new Thread(threadStart);
35.         if( thread.ManagedThreadId == unityThread.ManagedThreadId)
36.         {
37.             return GetThread(threadStart);
38.         }
39.         else
40.         {
41.             return thread;
42.         }
43.  
44.     }
45.  
46.     void DataThread(Func<object> function, Action<object> funcCallback)
47.     {
48.         object data = function();
49.         lock (dataQueue)
50.         {
51.             dataQueue.Enqueue(new ThreadData(funcCallback, data));
52.         }
53.     }
54.  
55.  
56.     void Update()
57.     {
58.         if (dataQueue.Count > 0)
59.         {
60.             for (int i = 0; i < dataQueue.Count; i++)
61.             {
62.                 ThreadData threadInfo = dataQueue.Dequeue();
63.                 threadInfo.funcCallback(threadInfo.function);
64.             }
65.         }
66.     }
67.  
68.     struct ThreadData
69.     {
70.         public readonly Action<object> funcCallback;
71.         public readonly object function;
72.  
73.         public ThreadData(Action<object> funcCallback, object function)
74.         {
75.             this.funcCallback = funcCallback;
76.             this.function = function;
77.         }
78.     }
79. }
80.  

Runs a new thread with "GetQuadMesh", and after its finished runs "OnQuadMeshReceived" on the main thread.

Code (CSharp):

1.         void Update()
2.         {
3.             ThreadedQuadRequester.RequestData(() => GetQuadMesh(this.position, mapSettings, this.quadLOD, RunMethod.Load), OnQuadMeshReceived);
4.         }

Profile


As seen above here it peeks hard. And some how these threads seems to be followed by the main thread from start to finish with in the same frame. And thats not needed. All that is needed is that that the callback gets performed once its done what ever frame this is in.

One more thing, right now it dose not matter that much how large area is set for producing data, its pretty much the same spike and time it freezes up.

Am I missing something here?