Need strategy for multithreading in unity

My unity project is a procedural environment on Android and creates terrains and stuff at runtime. The overall workflow I use is to calculate anything non-unity in a worker thread and when the data is calculated, I call Unity API within the main thread.

The problem is that sometimes (like every 200 frames) the worker thread affects the main thread's performance. That could show itself with a nasty spike in rendering time.

So what to do with multithreading in unity?

PS: Not exactly the main issue but to make the question more concrete, I will include the worker thread implementation. It is a modified version of the worker thread implementation suggested in this stackoverflow post. The modified version is like this:

 public static class JobScheduler
 {
 private static Queue<Job> Jobs = new Queue<Job>();
 private static volatile bool isBusy;
 private static ManualResetEvent _workAvailable = new ManualResetEvent(false);
 static JobScheduler()
 {
     var backgroundWorkThread = new Thread(BackgroundThread)
     {
         IsBackground = true,
         Priority = ThreadPriority.Lowest,
         Name = "BasicBackgroundWorker Thread"
     };
     backgroundWorkThread.Start();
 }
 
 private static void BackgroundThread()
 {
     int jobCnt;
     while (true)
     {
         Job? workItem=null;
         lock (Jobs)
         {
             jobCnt = Jobs.Count;
             if (jobCnt != 0 && !isBusy)
             {
                 workItem = Jobs.Dequeue();
             }
         }
         if (workItem!=null)
         {
             isBusy = true;
             workItem.Value.callback(workItem.Value.param);
         }
         else
         {
             _workAvailable.WaitOne();
             _workAvailable.Reset();
         }
     }
 }
 public static void AddJob(Job Job)
 {
     lock (Jobs)
     {
             Jobs.Enqueue(Job);
     }
         _workAvailable.Set();
 }
 
 public static void JobDone()
 {
     isBusy = false;
     _workAvailable.Set();
 }
 
 }

And the Job struct is:

 public struct Job
 {
 public object param;
 public WaitCallback callback;
 public Job(WaitCallback callBackP
     , object parameter)
 {
     callback = callBackP;
     param = parameter;
 }
 }

Whenever needed I call JobScheduler.AddJob to enqueue a job and call JobScheduler.JobDone after the job is done to allow the next job to run.

Also the ThreadPool is not an option since it produces unnecessary garbage and is not very flexible to use.