Multithreading - C++ - Emulate Async Behaviour in Python

Question

I have to wrap an async behaviour using C++.

All the data passing has been done through the pybind11/stl.h . I am not sharing memory among python and C++ but the python instance of the C++ class itself. My question arises since I have already run asynchronous tasks within a C++ bind function and I have never had problems( i.e if I did a cpp main and a python main the results where the same, while having C++ running threads asynchronously wrt the main I get some sync issues only when the main is Python). My question is do I have to keep debugging my code since everything should run the same? or the GIL causes me problems having the Cpp object used among multiple threads?

IMHO I think having C++ and Python on the same instance with multiple threads could be an Issue.

What I am trying to do is:

Write a C++ class where:

• First method: Spawns a thread and keeps the handler in the class scope.
• Second method: Returns a Boolean (True if the computation running in the first method is finished).
• Third Method: Return the C++ cached results by the first method computation.

From Python:

• Call the second method once in a while to see if the computation is finished.
• When Finished get the results.

Dummuy Code Example (IS THIS SAFE??) :

C++ Code to Call From Python:

    #include <vector>
    #include <thread>
    #include <atomic>
    #include <iostream>

    class DummyClass {
    private:
      std::vector<std::vector<double>> _data;
      std::atomic<bool> _isDone{false};
      const size_t _target = 100;
      std::vector<std::thread> _workers;

    public:
    DummyClass() = default;

    ~DummyClass() {
        for (auto& t : _workers)
            t.join();

        _workers.clear();
    }
    void do_dummy_async_task() {
        

         auto dummy_task = [&]() {
           using namespace std::chrono_literals;
           std::cout << "Dummy task started" << std::endl;
           // Doing slow stuff on class memory
           for (int i = 0; i < _target; i++) {
                std::this_thread::sleep_for(5ms);
                _data.push_back(std::vector<double>(1000, 0)); 
           }
           std::cout << "Dummy Task ended" << std::endl;
           _isDone = true;};

        _workers.emplace_back(dummy_task);
        return;
    }
    bool isDone() {
        return _isDone;
    }
    std::vector<std::vector<double>> get_results(){
        return _data;
    }
    size_t get_number_of_targets() {
        return _target;
    }};

Python Main:

    from pyDummy import DummyClass
    import time

    def run_main():
       obj = DummyClass()
       expecting = obj.get_number_of_results()
       obj.do_async_task()
    
       print("Doing python things while Compiled Code does something else")
    
       while(not obj.is_Done()):
         time.sleep(1)

       results = obj.get_results()
    
       print(f"Done:\nExpected {expecting} and got {len(results)}!")    
    
    if __name__ == "__main__":
       run_main()