CODEWITHSUNDEEP
c++multithreading
Nikhil
Nikhil

Reputation: 2280

Is it possible to kill a spinning thread?

I am using ZThreads to illustrate the question but my question applies to PThreads, Boost Threads and other such threading libraries in C++.

class MyClass: public Runnable
{
 public:
  void run()
   {
      while(1)
      {

      }
   }
}

I now launch this as follows:

MyClass *myClass = new MyClass();
Thread t1(myClass);

Is it now possible to kill (violently if necessary) this thread? I can do this for sure instead of the infinite loop I had a Thread::Sleep(100000) that is, if it is blocking. But can I kill a spinning thread (doing computation). If yes, how? If not, why not?

Upvotes: 3

Views: 2014

Answers (9)

Bharat Jain
Bharat Jain

Reputation: 177

Yes,

Define keepAlive variable as an int . Initially set the value of keepAlive=1 .

class MyClass: public Runnable
{
 public:
  void run()
   {
      while(keepAlive)
      {

      }
   }
}

Now, when every you want to kill thread just set the value of keepAlive=0 .

Q. How this works ?

A. Thread will be live until the execution of the function continuous . So it's pretty simple to Terminate a function . set the value of variable to 0 & it breaks which results in killing of thread . [This is the safest way I found till date] .

Upvotes: 0

MARK
MARK

Reputation: 2362

Not sure of the other libraries but in pthread library pthread_kill function is available pthread_kill

Upvotes: 0

BatchyX
BatchyX

Reputation: 5114

If you need to kill a thread, consider using a process instead.

Especially if you tell us that your "thread" is a while (true) loop that may sleep for a long period of time performing operations that are necessarily blocking. To me, that indicate a process-like behavior.

Processes can be terminated in a various number of ways at almost any time and always in a clean way. They may also offer more reliability in case of a crash.

Modern operating systems offer an array of interprocess communications facilities: sockets, pipes, shared memory, memory mapped files ... They may even exchange file descriptors.

Good OSes have copy-on-write mechanism, so processes are cheap to fork.

Note that if your operations can be made in a non-blocking way, then you should use a poll-like mechanism instead. Boost::asio may help there.

Upvotes: 1

Ghita
Ghita

Reputation: 4505

A general solution to the kind of question posted can be found in Herb Sutter article: Prefer Using Active Objects Instead of Naked Threads

This permits you to have something like this (excerpt from article):

class Active {
public:
  typedef function<void()> Message;

private:

  Active( const Active& );           // no copying
  void operator=( const Active& );    // no copying

  bool done;                         // le flag
  message_queue<Message> mq;        // le queue
  unique_ptr<thread> thd;          // le thread

  void Run() {
    while( !done ) {
      Message msg = mq.receive();
      msg();            // execute message
    } // note: last message sets done to true
  }

In the active object destructor you can have then:

~Active() {
    Send( [&]{ done = true; } ); ;
    thd->join();
  }

This solution promotes a clean thread function exist, and avoids all other issues related to an unclean thread termination.

Upvotes: 3

David
David

Reputation: 3442

Can't you do add something like below

do {

  //stuff here

} while (!abort)

And check the flag once in a while between computations if they are small and not too long (as in the loop above) or in the middle and abort the computation if it is long?

Upvotes: 0

Some programmer dude
Some programmer dude

Reputation: 409442

As people already said, there is no portable way to kill a thread, and in some cases not possible at all. If you have control over the code (i.e. can modify it) one of the simplest ways is to have a boolean variable that the thread checks in regular intervals, and if set then terminate the thread as soon as possible.

Upvotes: 0

RobH
RobH

Reputation: 3348

As far as Windows goes (from MSDN):

TerminateThread is a dangerous function that should only be used in the most extreme cases. You should call TerminateThread only if you know exactly what the target thread is doing, and you control all of the code that the target thread could possibly be running at the time of the termination. For example, TerminateThread can result in the following problems:

If the target thread owns a critical section, the critical section will not be released.
If the target thread is allocating memory from the heap, the heap lock will not be released.
If the target thread is executing certain kernel32 calls when it is terminated, the kernel32 state for the thread's process could be inconsistent.
If the target thread is manipulating the global state of a shared DLL, the state of the DLL could be destroyed, affecting other users of the DLL.

Boost certainly doesn't have a thread-killing function.

Upvotes: 5

Ferruccio
Ferruccio

Reputation: 100728

It is possible to terminate a thread forcefully, but the call to do it is going to be platform specific. For example, under Windows you could do it with the TerminateThread function.

Keep in mind that if you use TerminateThread, the thread will not get a chance to release any resources it is using until the program terminates.

Upvotes: 1

user472155
user472155

Reputation:

You can with TerminateThread() API, but it is not recommended.

More details at: http://msdn.microsoft.com/en-us/library/windows/desktop/ms686717(v=vs.85).aspx

Upvotes: 0

Related Questions