How to force terminate std::thread by TerminateThread()?-CodePudding

I called IMFSourceReader::ReadSample and I found it was stuck if it cannot read data.

So I tried to terminate the thread by TerminateThread() but it returned 0 as a fail.

How could I terminate the stuck thread?

This is my sample code:

#include <iostream>
#include <vector>
#include <codecvt>
#include <string>
#include <thread>
#include <mutex>
#include <chrono>
#include <condition_variable>
#include <Windows.h>

using namespace std::chrono_literals;

class MyObject
{
private:
    ...

    std::thread *t;
    std::mutex m;
    std::condition_variable cv;
    std::thread::native_handle_type handle;

    int getsample(uint8_t* data)
    {
        // call a ReadSample
        hr = pVideoReader->ReadSample(
              MF_SOURCE_READER_ANY_STREAM,    // Stream index.
              0,                              // Flags.
              &streamIndex,                   // Receives the actual stream index. 
              &flags,                         // Receives status flags.
              &llTimeStamp,                   // Receives the time stamp.
              &pSample                        // Receives the sample or NULL.
        );

        ...

        return 0;
    }
    int myfunc_wrapper(uint8_t* data)
    {
        int ret = 0;
        BOOL bpass = 0;

        if (t == nullptr) {
            t = new std::thread([this, &data, &ret]()
                {
                    ret = this->getsample(data);
                    this->cv.notify_one();
                });
            handle = t->native_handle();
            t->detach();
        }

        {
            std::unique_lock<std::mutex> l(this->m);

            if (this->cv.wait_for(l, 2500ms) == std::cv_status::timeout) {
                bpass = TerminateThread(handle, 0);
                if (bpass == 0) {
                    std::cout << "TerminateThread Fail! " << GetLastError() << std::endl;
                }
                throw std::runtime_error("Timeout Fail 2500 ms");
            }
        }

        delete t;
        t = nullptr;
    }

public:

    int my_func(uint8_t* raw_data)
    {
        bool timedout = false;

        try {
            if (myfunc_wrapper(raw_data) != 0)
                return -1;
        }
        catch (std::runtime_error& e) {
            std::cout << e.what() << std::endl;
            timedout = true;
        }

        if (timedout)
            return -1;

        return 0;
    }
};

int main()
{
    uint8_t data[512];
    MyObject* obj = new MyObject();

    while (true)
    {
        obj->my_func(data);
    }

    return 0;
}

Output:

TerminateThread Fail! 6
Timeout Fail 2500 ms
TerminateThread Fail! 6
Timeout Fail 2500 ms
...

I also tried to use pthread_cancel but it cannot be compiled because there is a type error.

no suitable constructor exists to convert from "std::thread::native_handle_type" to "__ptw32_handle_t"

      handle = t->native_handle();
...
      pthread_cancel(handle); // no suitable constructor exists to convert

CodePudding user response：

The reason it failed to terminate is that the native handle is no longer valid after detaching, one way you could do this is to OpenThread using the thread id to get a new handle.

To get the thread id, you could use its handle before detaching like this:

DWORD nativeId = GetThreadId(t->native_handle());
t->detach();

After that, just open a new handle to the thread to terminate it:

HANDLE hThread = OpenThread(THREAD_TERMINATE, FALSE, nativeId);
if (hThread)
{
    BOOL result = TerminateThread(hThread, 0);
    CloseHandle(hThread);
}

But you should not do this, consider other ways to signal the thread to terminate on its own.