Proper use of threads with procedural generation

Hi everybody! I have been working on a simple chunk based terrain generation system, with voxel octrees. The overall method works pretty well, but testing this system with large amounts of chunks completely freezes the game/main thread until the generation process is finished. Looking for a solution, I read about threads and coroutines and I implemented a simple thread class (based on this template) to call the "generate" function from it. The only advantage I had was a faster generation, with full CPU usage, but the game still freezes until the chunks are completely loaded. Am I doing something wrong? Here some parts of the code:

 public class ChunkThread : ThreadedJob {
  
     public Chunk chunk;
  
     protected override void ThreadFunction()
     {
         chunk.root = chunk.root.BuildOctree (chunk.pos, Chunk.size, -1);
     }
  
     protected override void OnFinished()
     {
         chunk.RenderChunk ();
     }
 }

This is the simple Thread class I use to call the Build function, and the Render function when finished. This piece of code below is the start\update method for every Chunk gameObject (I kept only the relevant part), that simply creates the Thread instance and calls Start() pressing the mouse button.

 void Start () {
         t = new ChunkThread ();
         t.chunk = this;
     }
  
     void Update () {
         if (Input.GetButtonDown ("Fire1")) {
             t.Start ();
         }

Now, coming to the questions, what should I do to generate the terrain while still being able to play? Is there something wrong in my thread? Should I use a thread pool, if so how?

I used this template to build my thread class (it should be linked in the question). Anyway to avoid any doubt this is the ThreadedJob class

  public class ThreadedJob
  {
    private bool m_IsDone = false;
    private object m_Handle = new object();
    private System.Threading.Thread m_Thread = null;
    public bool IsDone
    {
      get
      {
        bool tmp;
        lock (m_Handle)
        {
           tmp = m_IsDone;
        }
        return tmp;
      }
      set
      {
        lock (m_Handle)
        {
           m_IsDone = value;
        }
      }
    }
    public virtual void Start()
    {
      m_Thread = new System.Threading.Thread(Run);
      m_Thread.Start();
    }
    public virtual void Abort()
    {
      m_Thread.Abort();
    }
    protected virtual void ThreadFunction() { }
    protected virtual void OnFinished() { }
    public virtual bool Update()
    {
      if (IsDone)
      {
        OnFinished();
        return true;
      }
      return false;
    }
    private void Run()
    {
      ThreadFunction();
      IsDone = true;
    }
  }