CODEWITHSUNDEEP
c++multithreading
tom timmer
tom timmer

Reputation: 1

Cannot kill std::thread

I have a program that I need to run a thread in. The problem is whenever I try to kill this thread from either inside the thread or outside the thread I get a "error 6 - invalid handle" error

class myclass
{
public:
    static myclass* inst()
    {
        if (oInst == nullptr) oInst = new myclass;
        return oInst;
    };
    void main();

    void start();


    void ex_stop()
    {
        //HANDLE Stopper = Killer.native_handle();
        //TerminateThread(Stopper, 0);
    }
}
private:
    std::thread Killer;

}

void myclass::start()
{
    Killer = std::thread(&myclass::ex_main, this);
    Killer.detach();
}

void myclass::main()
{
    ...
    if (0 == TerminateThread(Killer.native_handle(), 0))
    {
            char error[200];


            sprintf(error, "error %i\n", GetLastError());

            printf(error);
    }

This is how I start the class/thread

    myclass::inst()->start();

I've also tried making std::thread Killer an extern and declaring it in my .cpp and .h files, this way I can access it from outside the class, but I still get the same "error 6, invalid thread handle" error.

Can someone please tell me what's wrong with this code? Thanks

Upvotes: 0

Views: 198

Answers (1)

UKMonkey
UKMonkey

Reputation: 6993

The usual way of having a worker thread set up is to put it into a loop, and on each loop check to see if a boolean atomic has been changed ... something that would look like (but this probably doesn't compile straight off; the threadMain will probably need binding)

class myThreadJob {
  public:

  myThreadJob(): 
    doRun(true),
    thread(threadMain)
  {}

  void threadMain() {
      while (doRun) {...}
  }

  void stop() {
      doRun = false;
      thread.join();
  }

  private:
  std::atomic<bool> doRun;
  std::thread thread;
}

You've not said if your thread is a will do many tasks in a queue, or if it's a one off job that it's doing, but in any case if it's expected to be a long lived thread, it should check periodically that it can still run.

Because you've called detach() on your thread, your thread is no longer associated with your process. You can think of detach() as a declaration that the thread does not need anything local to the creating thread. You are not allowed to join it; and you're expecting it to run to termination.

Upvotes: 1

Related Questions