gil_scoped_acquire re-entry in c++ multi thread

[trobr]

int count = 0;
std::mutex PyOutput::mutex_;
void       PyOutput::wait_step(py::object fut)
{
    auto result = step();

    {
        // std::lock_guard<std::mutex> lock{AWaitablePyGenerateOutputs::mutex_};
        py::gil_scoped_acquire acquire{};
        count++;
        
        // Print the result
        std::cout << "wait step 33 : " << " count: " << count << std::endl;

        fut.attr("get_loop")().attr("call_soon_threadsafe")(fut.attr("set_result"), result);
        count--;
    }
}

py::object PyOutput::wait(py::object py_future)
{
    cur_future_ = std::async(std::launch::async, &PyOutput::wait_step, this, py_future);
    return py_future;
}

void registerPyOutput(py::module m)
{
    pybind11::class_<PyOutput>(m, "PyOutput")
        .def(pybind11::init<>())
        .def("wait", &PyOutput::wait, py::call_guard<py::gil_scoped_release>());
}

and the python code like:

async def forward(input):
    output = forward_cpp(input)
    while True:
        fut = asyncio.get_event_loop().create_future()
        output.wait(fut)
        result = await fut
        if result.finished:
            break
        yield result

In my code, I start an asynchronous thread in C++ to execute wait_step by calling a wait function in Python. This thread waits for the result from another C++ thread and writes the result back to the asyncio.future object after obtaining it. Since the call in Python is asynchronous, many C++ threads might be executing wait_step at the same time.

However, I encountered an issue where the wait_step function in C++ occasionally deadlocks when acquiring the GIL with py::gil_scoped_acquire acquire{}. I tried using a count to record the number of threads entering this code simultaneously. Theoretically, the printed count value should always be 1, but I got results greater than 1. Does this mean that multiple C++ threads are acquiring the GIL simultaneously?

Then, I tried adding std::mutex before entering the code segment, and the deadlock did not occur again.

I have looked into some other related issues, but they did not solve my problem.
#1087

why does this happen? Am I using py::gil_scoped_acquire incorrectly, or are there implicit rules I haven’t followed (such as proper initialization of the interpreter, GIL, etc.)?

Thanks.