common taskscheduler: fix a potential crash issue.

Guarantee the tasks are not deleted until the taskscheduler finished them.

@Issue: https://github.com/thorvg/thorvg/issues/1370

src/lib/tvgTaskScheduler.cpp

@@ -105,7 +105,7 @@ struct TaskSchedulerImpl
     uint32_t                       threadCnt;
     vector<thread>                 threads;
     vector<TaskQueue>              taskQueues;
-    uint32_t                       idx = 0;
+    atomic<uint32_t>               idx{0};
 
     TaskSchedulerImpl(unsigned threadCnt) : threadCnt(threadCnt), taskQueues(threadCnt)
     {

src/lib/tvgTaskScheduler.h

@@ -43,56 +43,83 @@ struct TaskScheduler
 struct Task
 {
 private:
-    mutex                   mtx;
+    mutex                   finishedMtx;
-    bool                    finished = true;
+    mutex                   preparedMtx;
-    bool                    running = false;
+    condition_variable      cv;
+    bool                    finished = true;        //if run() finished
+    bool                    prepared = false;       //the task is requested
 
 public:
-    virtual ~Task() = default;
+    virtual ~Task()
+    {
+        if (!prepared) return;
+
+        //Guarantee the task is finished by TaskScheduler.
+        unique_lock<mutex> lock(preparedMtx);
+
+        while (prepared) {
+            cv.wait(lock);
+        }
+    }
 
     void done(unsigned tid = 0)
     {
         if (finished) return;
 
-        unique_lock<mutex> lock(mtx);
+        lock_guard<mutex> lock(finishedMtx);
 
         if (finished) return;
 
         //the job hasn't been launched yet.
-        running = true;
+
-        run(tid);
+        //set finished so that operator() quickly returns.
-        running = false;
         finished = true;
+
+        run(tid);
     }
 
 protected:
     virtual void run(unsigned tid) = 0;
 
 private:
+    void finish()
+    {
+        lock_guard<mutex> lock(preparedMtx);
+        prepared = false;
+        cv.notify_one();
+    }
+
     void operator()(unsigned tid)
     {
-        if (finished || running) return;
+        if (finished) {
+            finish();
+            return;
+        }
 
-        lock_guard<mutex> lock(mtx);
+        lock_guard<mutex> lock(finishedMtx);
 
-        if (finished || running) return;
+        if (finished) {
+            finish();
+            return;
+        }
 
-        running = true;
         run(tid);
-        running = false;
+
         finished = true;
+
+        finish();
     }
 
     void prepare()
     {
         finished = false;
+        prepared = true;
     }
 
     friend struct TaskSchedulerImpl;
 };
 
-
-
 }
 
 #endif //_TVG_TASK_SCHEDULER_H_
+