Is there any way to kill a Thread

Question

Is it possible to terminate a running thread without setting checking any flags semaphores etc

User · Answer

You can kill a thread by installing trace into the thread that will exit the thread    See attached link for one possible implementation   Kill a thread in Python

User · Answer

A multiprocessing Process can p terminate   In the cases where I want to kill a thread  but do not want to use flags locks signals semaphores events whatever  I promote the threads to full blown processes  For code that makes use of just a few threads the overhead is not that bad  E g  this comes in handy to easily terminate helper  quot threads quot  which execute blocking I O The conversion is trivial  In related code replace all threading Thread with multiprocessing Process and all queue Queue with multiprocessing Queue and add the required calls of p terminate   to your parent process which wants to kill its child p See the Python documentation for multiprocessing  Example  import multiprocessing proc   multiprocessing Process target your proc function  args     proc start     Terminate the process proc terminate      sends a SIGTERM

User · Answer

Start the sub thread with setDaemon True    def bootstrap  filename       mb   ModelBootstrap filename  filename    Has many Daemon threads  All get stopped automatically when main thread is stopped   t   threading Thread target bootstrap args   models conf     t setDaemon False   while True      t start       time sleep 10    I am just allowing the sub-thread to run for 10 sec  You can listen on an event to stop execution      print  Thread stopped       break

User · Answer

Here s yet another way to do it  but with extremely clean and simple code  that works in Python 3 7 in 2021  import ctypes   def kill thread thread        quot  quot  quot      thread  a threading Thread object      quot  quot  quot      thread id   thread ident     res   ctypes pythonapi PyThreadState SetAsyncExc thread id  ctypes py object SystemExit       if res  gt  1          ctypes pythonapi PyThreadState SetAsyncExc thread id  0          print  Exception raise failure    Adapted from here  https   www geeksforgeeks org python-different-ways-to-kill-a-thread

User · Answer

If you really need the ability to kill a sub-task  use an alternate implementation  multiprocessing and gevent both support indiscriminately killing a  thread    Python s threading does not support cancellation  Do not even try  Your code is very likely to deadlock  corrupt or leak memory  or have other unintended  interesting  hard-to-debug effects which happen rarely and nondeterministically

User · Answer

If you really need the ability to kill a sub-task  use an alternate implementation  multiprocessing and gevent both support indiscriminately killing a  thread    Python s threading does not support cancellation  Do not even try  Your code is very likely to deadlock  corrupt or leak memory  or have other unintended  interesting  hard-to-debug effects which happen rarely and nondeterministically

User · Answer

Just to build up on  SCB s idea  which was exactly what I needed  to create a KillableThread  subclass with a customized function  from threading import Thread  Event  class KillableThread Thread       def   init   self  sleep interval 1  target None  name None  args     kwargs              super     init   None  target  name  args  kwargs          self  kill   Event           self  interval   sleep interval         print self  target       def run self           while True                Call custom function with arguments             self  target  self  args                 If no kill signal is set  sleep for the interval                If kill signal comes in while sleeping  immediately                wake up and handle             is killed   self  kill wait self  interval              if is killed                  break          print  quot Killing Thread quot        def kill self           self  kill set    if   name         main          def print msg msg           print msg       t   KillableThread 10  print msg  args   quot hello world quot        t start       time sleep 6      print  quot About to kill thread quot       t kill    Naturally  like with  SBC  the thread doesn t wait to run a new loop to stop  In this example  you would see the  quot Killing Thread quot  message printed right after the  quot About to kill thread quot  instead of waiting for 4 more seconds for the thread to complete  since we have slept for 6 seconds already   Second argument in KillableThread constructor is your custom function  print msg here   Args argument are the arguments that will be used when calling the function    quot hello world quot    here

User · Answer

This seems to work with pywin32 on windows 7  my thread   threading Thread   my thread start   my thread  Thread  stop

User · Answer

In Python  you simply cannot kill a Thread directly   If you do NOT really need to have a Thread      what you can do  instead of using the threading package   is to use the  multiprocessing package   Here  to kill a process  you can simply call the method   yourProcess terminate      kill the process    Python will kill your process  on Unix through the SIGTERM signal  while on Windows through the TerminateProcess   call   Pay attention to use it while using a Queue or a Pipe   it may corrupt the data in the Queue Pipe   Note that the multiprocessing Event and the multiprocessing Semaphore work exactly in the same way of the threading Event and the threading Semaphore respectively  In fact  the first ones are clones of the latters   If you REALLY need to use a Thread  there is no way to kill it directly  What you can do  however  is to use a  daemon thread   In fact  in Python  a Thread can be flagged as daemon   yourThread daemon   True    set the Thread as a  daemon thread    The main program will exit when no alive non-daemon threads are left  In other words  when your main thread  which is  of course  a non-daemon thread  will finish its operations  the program will exit even if there are still some daemon threads working   Note that it is necessary to set a Thread as daemon before the start   method is called   Of course you can  and should  use daemon even with multiprocessing  Here  when the main process exits  it attempts to terminate all of its daemonic child processes   Finally  please  note that sys exit   and os kill   are not choices

User · Answer

There is no official API to do that  no   You need to use platform API to kill the thread  e g  pthread kill  or TerminateThread  You can access such API e g  through pythonwin  or through ctypes   Notice that this is inherently unsafe  It will likely lead to uncollectable garbage  from local variables of the stack frames that become garbage   and may lead to deadlocks  if the thread being killed has the GIL at the point when it is killed

User · Answer

One thing I want to add is that if you read official documentation in threading lib Python  it s recommended to avoid use of  demonic  threads  when you don t want threads end abruptly  with the flag that Paolo Rovelli mentioned   From official documentation      Daemon threads are abruptly stopped at shutdown  Their resources  such as open files  database transactions  etc   may not be released properly  If you want your threads to stop gracefully  make them non-daemonic and use a suitable signaling mechanism such as an Event    I think that creating daemonic threads depends of your application  but in general  and in my opinion  it s better to avoid killing them or making them daemonic  In multiprocessing you can use is alive   to check process status  and  terminate  for finish them  Also you avoid GIL problems   But you can find more problems  sometimes  when you execute your code in Windows   And always remember that if you have  live threads   the Python interpreter will be running for wait them   Because of this daemonic can help you if don t matter abruptly ends

User · Answer

This seems to work with pywin32 on windows 7  my thread   threading Thread   my thread start   my thread  Thread  stop

User · Answer

As mentioned in  Kozyarchuk s answer  installing trace works  Since this answer contained no code  here is a working ready-to-use example   import sys  threading  time   class TraceThread threading Thread        def   init   self   args    keywords            threading Thread   init   self   args    keywords           self killed   False     def start self            self  run   self run          self run   self settrace and run         threading Thread start self       def settrace and run self            sys settrace self globaltrace           self  run       def globaltrace self  frame  event  arg            return self localtrace if event     call  else None     def localtrace self  frame  event  arg            if self killed and event     line                raise SystemExit            return self localtrace   def f         while True           print  1            time sleep 2          print  2            time sleep 2          print  3            time sleep 2   t   TraceThread target f   t start    time sleep 2 5   t killed   True   It stops after having printed 1 and 2  3 is not printed

User · Answer

As mentioned in  Kozyarchuk s answer  installing trace works  Since this answer contained no code  here is a working ready-to-use example   import sys  threading  time   class TraceThread threading Thread        def   init   self   args    keywords            threading Thread   init   self   args    keywords           self killed   False     def start self            self  run   self run          self run   self settrace and run         threading Thread start self       def settrace and run self            sys settrace self globaltrace           self  run       def globaltrace self  frame  event  arg            return self localtrace if event     call  else None     def localtrace self  frame  event  arg            if self killed and event     line                raise SystemExit            return self localtrace   def f         while True           print  1            time sleep 2          print  2            time sleep 2          print  3            time sleep 2   t   TraceThread target f   t start    time sleep 2 5   t killed   True   It stops after having printed 1 and 2  3 is not printed

User · Answer

It is definitely possible to implement a Thread stop method as shown in the following example code   import sys import threading import time   class StopThread StopIteration       pass  threading SystemExit   SystemExit  StopThread   class Thread2 threading Thread        def stop self           self   stop   True      def  bootstrap self           if threading  trace hook is not None              raise ValueError  Cannot run thread with tracing            self   stop   False         sys settrace self   trace          super    bootstrap        def   trace self  frame  event  arg           if self   stop              raise StopThread           return self   trace   class Thread3 threading Thread        def  bootstrap self  stop thread False           def stop                nonlocal stop thread             stop thread   True         self stop   stop          def tracer                  if stop thread                  raise StopThread               return tracer         sys settrace tracer          super    bootstrap                                                                                      def main        test1   Thread2 target printer      test1 start       time sleep 1      test1 stop       test1 join       test2   Thread2 target speed test      test2 start       time sleep 1      test2 stop       test2 join       test3   Thread3 target speed test      test3 start       time sleep 1      test3 stop       test3 join     def printer        while True          print time time     1          time sleep 0 1    def speed test count 0       try          while True              count    1     except StopThread          print  Count     count   if   name         main         main     The Thread3 class appears to run code approximately 33  faster than the Thread2 class

User · Answer

If you are explicitly calling time sleep   as part of your thread  say polling some external service   an improvement upon Phillipe s method is to use the timeout in the event s wait   method wherever you sleep    For example   import threading  class KillableThread threading Thread       def   init   self  sleep interval 1           super     init             self  kill   threading Event           self  interval   sleep interval      def run self           while True              print  Do Something                  If no kill signal is set  sleep for the interval                If kill signal comes in while sleeping  immediately                wake up and handle             is killed   self  kill wait self  interval              if is killed                  break          print  Killing Thread        def kill self           self  kill set     Then to run it  t   KillableThread sleep interval 5  t start     Every 5 seconds it prints     Do Something t kill      Killing Thread   The advantage of using wait   instead of sleep  ing and regularly checking the event is that you can program in longer intervals of sleep  the thread is stopped almost immediately  when you would otherwise be sleep  ing  and in my opinion  the code for handling exit is significantly simpler

User · Answer

This is based on thread2 -- killable threads  Python recipe   You need to call PyThreadState SetasyncExc    which is only available through ctypes   This has only been tested on Python 2 7 3  but it is likely to work with other recent 2 x releases   import ctypes  def terminate thread thread          Terminates a python thread from another thread        param thread  a threading Thread instance             if not thread isAlive            return      exc   ctypes py object SystemExit      res   ctypes pythonapi PyThreadState SetAsyncExc          ctypes c long thread ident   exc      if res    0          raise ValueError  nonexistent thread id       elif res  gt  1               if it returns a number greater than one  you re in trouble            and you should call it again with exc NULL to revert the effect            ctypes pythonapi PyThreadState SetAsyncExc thread ident  None          raise SystemError  PyThreadState SetAsyncExc failed

User · Answer

If you are trying to terminate the whole program you can set the thread as a  daemon   see Thread daemon

User · Answer

It is better if you don t kill a thread  A way could be to introduce a  try  block into the thread s cycle and to throw an exception when you want to stop the thread  for example a break return     that stops your for while        I ve used this on my app and it works

User · Answer

There is a library built for this purpose  stopit  Although some of the same cautions listed herein still apply  at least this library presents a regular  repeatable technique for achieving the stated goal

User · Answer

There is no official API to do that  no   You need to use platform API to kill the thread  e g  pthread kill  or TerminateThread  You can access such API e g  through pythonwin  or through ctypes   Notice that this is inherently unsafe  It will likely lead to uncollectable garbage  from local variables of the stack frames that become garbage   and may lead to deadlocks  if the thread being killed has the GIL at the point when it is killed

User · Answer

This is based on thread2 -- killable threads  Python recipe   You need to call PyThreadState SetasyncExc    which is only available through ctypes   This has only been tested on Python 2 7 3  but it is likely to work with other recent 2 x releases   import ctypes  def terminate thread thread          Terminates a python thread from another thread        param thread  a threading Thread instance             if not thread isAlive            return      exc   ctypes py object SystemExit      res   ctypes pythonapi PyThreadState SetAsyncExc          ctypes c long thread ident   exc      if res    0          raise ValueError  nonexistent thread id       elif res  gt  1               if it returns a number greater than one  you re in trouble            and you should call it again with exc NULL to revert the effect            ctypes pythonapi PyThreadState SetAsyncExc thread ident  None          raise SystemError  PyThreadState SetAsyncExc failed

User · Answer

You can kill a thread by installing trace into the thread that will exit the thread    See attached link for one possible implementation   Kill a thread in Python

User · Answer

There is no official API to do that  no   You need to use platform API to kill the thread  e g  pthread kill  or TerminateThread  You can access such API e g  through pythonwin  or through ctypes   Notice that this is inherently unsafe  It will likely lead to uncollectable garbage  from local variables of the stack frames that become garbage   and may lead to deadlocks  if the thread being killed has the GIL at the point when it is killed

User · Answer

While it s rather old  this might be a handy solution for some        A little module that extends the threading s module functionality --   allows one thread to raise exceptions in the context of another   thread  By raising SystemExit  you can finally kill python threads    import threading import ctypes       def  async raise tid  excobj       res   ctypes pythonapi PyThreadState SetAsyncExc tid  ctypes py object excobj       if res    0          raise ValueError  nonexistent thread id       elif res  gt  1               if it returns a number greater than one  you re in trouble             and you should call it again with exc NULL to revert the effect            ctypes pythonapi PyThreadState SetAsyncExc tid  0          raise SystemError  PyThreadState SetAsyncExc failed    class Thread threading Thread       def raise exc self  excobj           assert self isAlive     thread must be started          for tid  tobj in threading  active items                if tobj is self                   async raise tid  excobj                  return            the thread was alive when we entered the loop  but was not found            in the dict  hence it must have been already terminated  should we raise           an exception here  silently ignore       def terminate self             must raise the SystemExit type  instead of a SystemExit   instance           due to a bug in PyThreadState SetAsyncExc         self raise exc SystemExit    So  it allows a  thread to raise exceptions in the context of another thread  and in this way  the terminated thread can handle the termination without regularly checking an abort flag   However  according to its original source  there are some issues with this code         The exception will be raised only when executing python bytecode  If    your thread calls a native built-in blocking function  the   exception    will be raised only when execution returns to the python   code           There is also an issue if the built-in function internally calls    PyErr Clear    which would effectively cancel your pending exception     You can try to raise it again       Only exception types can be raised    safely  Exception instances are likely to cause unexpected behavior     and are thus restricted          For example  t1 raise exc TypeError  and    not t1 raise exc TypeError  blah       IMHO it s a bug  and I reported it as one  For more info     http   mail python org pipermail python-dev 2006-August 068158 html        I asked to expose this function in the built-in thread module  but    since ctypes has become a standard library  as of 2 5   and this   feature is not likely to be implementation-agnostic  it may be kept   unexposed

User · Answer

It is generally a bad pattern to kill a thread abruptly  in Python  and in any language  Think of the following cases   the thread is holding a critical resource that must be closed properly the thread has created several other threads that must be killed as well   The nice way of handling this  if you can afford it  if you are managing your own threads   is to have an exit request flag that each thread checks on a regular interval to see if it is time for it to exit  For example  import threading  class StoppableThread threading Thread        quot  quot  quot Thread class with a stop   method  The thread itself has to check     regularly for the stopped   condition  quot  quot  quot       def   init   self    args    kwargs           super StoppableThread  self    init    args    kwargs          self  stop event   threading Event        def stop self           self  stop event set        def stopped self           return self  stop event is set    In this code  you should call stop   on the thread when you want it to exit  and wait for the thread to exit properly using join    The thread should check the stop flag at regular intervals  There are cases  however  when you really need to kill a thread  An example is when you are wrapping an external library that is busy for long calls  and you want to interrupt it  The following code allows  with some restrictions  to raise an Exception in a Python thread  def  async raise tid  exctype          Raises an exception in the threads with id tid        if not inspect isclass exctype           raise TypeError  quot Only types can be raised  not instances  quot       res   ctypes pythonapi PyThreadState SetAsyncExc ctypes c long tid                                                        ctypes py object exctype       if res    0          raise ValueError  quot invalid thread id quot       elif res    1             quot if it returns a number greater than one  you re in trouble            and you should call it again with exc NULL to revert the effect quot          ctypes pythonapi PyThreadState SetAsyncExc ctypes c long tid   None          raise SystemError  quot PyThreadState SetAsyncExc failed quot    class ThreadWithExc threading Thread          A thread class that supports raising an exception in the thread from        another thread              def  get my tid self            quot  quot  quot determines this  self s  thread id          CAREFUL  this function is executed in the context of the caller         thread  to get the identity of the thread represented by this         instance           quot  quot  quot          if not self isAlive                raise threading ThreadError  quot the thread is not active quot              do we have it cached          if hasattr self   quot  thread id quot                return self  thread id            no  look for it in the  active dict         for tid  tobj in threading  active items                if tobj is self                  self  thread id   tid                 return tid            TODO  in python 2 6  there s a simpler way to do  self ident          raise AssertionError  quot could not determine the thread s id quot        def raiseExc self  exctype            quot  quot  quot Raises the given exception type in the context of this thread           If the thread is busy in a system call  time sleep            socket accept          the exception is simply ignored           If you are sure that your exception should terminate the thread          one way to ensure that it works is               t   ThreadWithExc                                    t raiseExc  SomeException               while t isAlive                    time sleep  0 1                   t raiseExc  SomeException            If the exception is to be caught by the thread  you need a way to         check that your thread has caught it           CAREFUL  this function is executed in the context of the         caller thread  to raise an exception in the context of the         thread represented by this instance           quot  quot  quot           async raise  self  get my tid    exctype     Based on Killable Threads by Tomer Filiba  The quote about the return value of PyThreadState SetAsyncExc appears to be from an old version of Python   As noted in the documentation  this is not a magic bullet because if the thread is busy outside the Python interpreter  it will not catch the interruption  A good usage pattern of this code is to have the thread catch a specific exception and perform the cleanup  That way  you can interrupt a task and still have proper cleanup

User · Answer

You should never forcibly kill a thread without cooperating with it   Killing a thread removes any guarantees that try finally blocks set up so you might leave locks locked  files open  etc   The only time you can argue that forcibly killing threads is a good idea is to kill a program fast  but never single threads

User · Answer

As others have mentioned  the norm is to set a stop flag  For something lightweight  no subclassing of Thread  no global variable   a lambda callback is an option   Note the parentheses in if stop      import threading import time  def do work id  stop       print  I am thread   id      while True          print  I am thread    doing something  format id           if stop                print    Exiting loop                break     print  Thread     signing off  format id     def main        stop threads   False     workers          for id in range 0 3           tmp   threading Thread target do work  args  id  lambda  stop threads           workers append tmp          tmp start       time sleep 3      print  main  done sleeping  time to stop the threads        stop threads   True     for worker in workers          worker join       print  Finis     if   name         main         main     Replacing print   with a pr   function that always flushes  sys stdout flush    may improve the precision of the shell output    Only tested on Windows Eclipse Python3 3

User · Answer

It is generally a bad pattern to kill a thread abruptly  in Python  and in any language  Think of the following cases   the thread is holding a critical resource that must be closed properly the thread has created several other threads that must be killed as well   The nice way of handling this  if you can afford it  if you are managing your own threads   is to have an exit request flag that each thread checks on a regular interval to see if it is time for it to exit  For example  import threading  class StoppableThread threading Thread        quot  quot  quot Thread class with a stop   method  The thread itself has to check     regularly for the stopped   condition  quot  quot  quot       def   init   self    args    kwargs           super StoppableThread  self    init    args    kwargs          self  stop event   threading Event        def stop self           self  stop event set        def stopped self           return self  stop event is set    In this code  you should call stop   on the thread when you want it to exit  and wait for the thread to exit properly using join    The thread should check the stop flag at regular intervals  There are cases  however  when you really need to kill a thread  An example is when you are wrapping an external library that is busy for long calls  and you want to interrupt it  The following code allows  with some restrictions  to raise an Exception in a Python thread  def  async raise tid  exctype          Raises an exception in the threads with id tid        if not inspect isclass exctype           raise TypeError  quot Only types can be raised  not instances  quot       res   ctypes pythonapi PyThreadState SetAsyncExc ctypes c long tid                                                        ctypes py object exctype       if res    0          raise ValueError  quot invalid thread id quot       elif res    1             quot if it returns a number greater than one  you re in trouble            and you should call it again with exc NULL to revert the effect quot          ctypes pythonapi PyThreadState SetAsyncExc ctypes c long tid   None          raise SystemError  quot PyThreadState SetAsyncExc failed quot    class ThreadWithExc threading Thread          A thread class that supports raising an exception in the thread from        another thread              def  get my tid self            quot  quot  quot determines this  self s  thread id          CAREFUL  this function is executed in the context of the caller         thread  to get the identity of the thread represented by this         instance           quot  quot  quot          if not self isAlive                raise threading ThreadError  quot the thread is not active quot              do we have it cached          if hasattr self   quot  thread id quot                return self  thread id            no  look for it in the  active dict         for tid  tobj in threading  active items                if tobj is self                  self  thread id   tid                 return tid            TODO  in python 2 6  there s a simpler way to do  self ident          raise AssertionError  quot could not determine the thread s id quot        def raiseExc self  exctype            quot  quot  quot Raises the given exception type in the context of this thread           If the thread is busy in a system call  time sleep            socket accept          the exception is simply ignored           If you are sure that your exception should terminate the thread          one way to ensure that it works is               t   ThreadWithExc                                    t raiseExc  SomeException               while t isAlive                    time sleep  0 1                   t raiseExc  SomeException            If the exception is to be caught by the thread  you need a way to         check that your thread has caught it           CAREFUL  this function is executed in the context of the         caller thread  to raise an exception in the context of the         thread represented by this instance           quot  quot  quot           async raise  self  get my tid    exctype     Based on Killable Threads by Tomer Filiba  The quote about the return value of PyThreadState SetAsyncExc appears to be from an old version of Python   As noted in the documentation  this is not a magic bullet because if the thread is busy outside the Python interpreter  it will not catch the interruption  A good usage pattern of this code is to have the thread catch a specific exception and perform the cleanup  That way  you can interrupt a task and still have proper cleanup

User · Answer

A multiprocessing Process can p terminate   In the cases where I want to kill a thread  but do not want to use flags locks signals semaphores events whatever  I promote the threads to full blown processes  For code that makes use of just a few threads the overhead is not that bad  E g  this comes in handy to easily terminate helper  quot threads quot  which execute blocking I O The conversion is trivial  In related code replace all threading Thread with multiprocessing Process and all queue Queue with multiprocessing Queue and add the required calls of p terminate   to your parent process which wants to kill its child p See the Python documentation for multiprocessing  Example  import multiprocessing proc   multiprocessing Process target your proc function  args     proc start     Terminate the process proc terminate      sends a SIGTERM

User · Answer

This is a bad answer  see the comments   Here s how to do it   from threading import         for thread in enumerate        if thread isAlive            try              thread  Thread  stop           except              print str thread getName        could not be terminated      Give it a few seconds then your thread should be stopped  Check also the thread  Thread  delete   method   I d recommend a thread quit   method for convenience  For example if you have a socket in your thread  I d recommend creating a quit   method in your socket-handle class  terminate the socket  then run a thread  Thread  stop   inside of your quit

User · Answer

Following workaround can be used to kill a thread   kill threads   False  def doSomething        global kill threads     while True          if kill threads              thread exit                                  thread start new thread doSomething        This can be used even for terminating threads  whose code is written in another module  from main thread  We can declare a global variable in that module and use it to terminate thread s spawned in that module   I usually use this to terminate all the threads at the program exit  This might not be the perfect way to terminate thread s but could help

User · Answer

from ctypes import   pthread   cdll LoadLibrary  libpthread-2 15 so   pthread pthread cancel c ulong t ident     t is your Thread object   Read the python source  Modules threadmodule c and Python thread pthread h  you can see the Thread ident is an pthread t type  so you can do anything pthread can do in python use libpthread

User · Answer

One thing I want to add is that if you read official documentation in threading lib Python  it s recommended to avoid use of  demonic  threads  when you don t want threads end abruptly  with the flag that Paolo Rovelli mentioned   From official documentation      Daemon threads are abruptly stopped at shutdown  Their resources  such as open files  database transactions  etc   may not be released properly  If you want your threads to stop gracefully  make them non-daemonic and use a suitable signaling mechanism such as an Event    I think that creating daemonic threads depends of your application  but in general  and in my opinion  it s better to avoid killing them or making them daemonic  In multiprocessing you can use is alive   to check process status  and  terminate  for finish them  Also you avoid GIL problems   But you can find more problems  sometimes  when you execute your code in Windows   And always remember that if you have  live threads   the Python interpreter will be running for wait them   Because of this daemonic can help you if don t matter abruptly ends

User · Answer

You can kill a thread by installing trace into the thread that will exit the thread    See attached link for one possible implementation   Kill a thread in Python

User · Answer

If you are explicitly calling time sleep   as part of your thread  say polling some external service   an improvement upon Phillipe s method is to use the timeout in the event s wait   method wherever you sleep    For example   import threading  class KillableThread threading Thread       def   init   self  sleep interval 1           super     init             self  kill   threading Event           self  interval   sleep interval      def run self           while True              print  Do Something                  If no kill signal is set  sleep for the interval                If kill signal comes in while sleeping  immediately                wake up and handle             is killed   self  kill wait self  interval              if is killed                  break          print  Killing Thread        def kill self           self  kill set     Then to run it  t   KillableThread sleep interval 5  t start     Every 5 seconds it prints     Do Something t kill      Killing Thread   The advantage of using wait   instead of sleep  ing and regularly checking the event is that you can program in longer intervals of sleep  the thread is stopped almost immediately  when you would otherwise be sleep  ing  and in my opinion  the code for handling exit is significantly simpler

User · Answer

You should never forcibly kill a thread without cooperating with it   Killing a thread removes any guarantees that try finally blocks set up so you might leave locks locked  files open  etc   The only time you can argue that forcibly killing threads is a good idea is to kill a program fast  but never single threads

User · Answer

It is generally a bad pattern to kill a thread abruptly  in Python  and in any language  Think of the following cases   the thread is holding a critical resource that must be closed properly the thread has created several other threads that must be killed as well   The nice way of handling this  if you can afford it  if you are managing your own threads   is to have an exit request flag that each thread checks on a regular interval to see if it is time for it to exit  For example  import threading  class StoppableThread threading Thread        quot  quot  quot Thread class with a stop   method  The thread itself has to check     regularly for the stopped   condition  quot  quot  quot       def   init   self    args    kwargs           super StoppableThread  self    init    args    kwargs          self  stop event   threading Event        def stop self           self  stop event set        def stopped self           return self  stop event is set    In this code  you should call stop   on the thread when you want it to exit  and wait for the thread to exit properly using join    The thread should check the stop flag at regular intervals  There are cases  however  when you really need to kill a thread  An example is when you are wrapping an external library that is busy for long calls  and you want to interrupt it  The following code allows  with some restrictions  to raise an Exception in a Python thread  def  async raise tid  exctype          Raises an exception in the threads with id tid        if not inspect isclass exctype           raise TypeError  quot Only types can be raised  not instances  quot       res   ctypes pythonapi PyThreadState SetAsyncExc ctypes c long tid                                                        ctypes py object exctype       if res    0          raise ValueError  quot invalid thread id quot       elif res    1             quot if it returns a number greater than one  you re in trouble            and you should call it again with exc NULL to revert the effect quot          ctypes pythonapi PyThreadState SetAsyncExc ctypes c long tid   None          raise SystemError  quot PyThreadState SetAsyncExc failed quot    class ThreadWithExc threading Thread          A thread class that supports raising an exception in the thread from        another thread              def  get my tid self            quot  quot  quot determines this  self s  thread id          CAREFUL  this function is executed in the context of the caller         thread  to get the identity of the thread represented by this         instance           quot  quot  quot          if not self isAlive                raise threading ThreadError  quot the thread is not active quot              do we have it cached          if hasattr self   quot  thread id quot                return self  thread id            no  look for it in the  active dict         for tid  tobj in threading  active items                if tobj is self                  self  thread id   tid                 return tid            TODO  in python 2 6  there s a simpler way to do  self ident          raise AssertionError  quot could not determine the thread s id quot        def raiseExc self  exctype            quot  quot  quot Raises the given exception type in the context of this thread           If the thread is busy in a system call  time sleep            socket accept          the exception is simply ignored           If you are sure that your exception should terminate the thread          one way to ensure that it works is               t   ThreadWithExc                                    t raiseExc  SomeException               while t isAlive                    time sleep  0 1                   t raiseExc  SomeException            If the exception is to be caught by the thread  you need a way to         check that your thread has caught it           CAREFUL  this function is executed in the context of the         caller thread  to raise an exception in the context of the         thread represented by this instance           quot  quot  quot           async raise  self  get my tid    exctype     Based on Killable Threads by Tomer Filiba  The quote about the return value of PyThreadState SetAsyncExc appears to be from an old version of Python   As noted in the documentation  this is not a magic bullet because if the thread is busy outside the Python interpreter  it will not catch the interruption  A good usage pattern of this code is to have the thread catch a specific exception and perform the cleanup  That way  you can interrupt a task and still have proper cleanup

User · Answer

You should never forcibly kill a thread without cooperating with it   Killing a thread removes any guarantees that try finally blocks set up so you might leave locks locked  files open  etc   The only time you can argue that forcibly killing threads is a good idea is to kill a program fast  but never single threads

User · Answer

There is no official API to do that  no   You need to use platform API to kill the thread  e g  pthread kill  or TerminateThread  You can access such API e g  through pythonwin  or through ctypes   Notice that this is inherently unsafe  It will likely lead to uncollectable garbage  from local variables of the stack frames that become garbage   and may lead to deadlocks  if the thread being killed has the GIL at the point when it is killed

User · Answer

While it s rather old  this might be a handy solution for some        A little module that extends the threading s module functionality --   allows one thread to raise exceptions in the context of another   thread  By raising SystemExit  you can finally kill python threads    import threading import ctypes       def  async raise tid  excobj       res   ctypes pythonapi PyThreadState SetAsyncExc tid  ctypes py object excobj       if res    0          raise ValueError  nonexistent thread id       elif res  gt  1               if it returns a number greater than one  you re in trouble             and you should call it again with exc NULL to revert the effect            ctypes pythonapi PyThreadState SetAsyncExc tid  0          raise SystemError  PyThreadState SetAsyncExc failed    class Thread threading Thread       def raise exc self  excobj           assert self isAlive     thread must be started          for tid  tobj in threading  active items                if tobj is self                   async raise tid  excobj                  return            the thread was alive when we entered the loop  but was not found            in the dict  hence it must have been already terminated  should we raise           an exception here  silently ignore       def terminate self             must raise the SystemExit type  instead of a SystemExit   instance           due to a bug in PyThreadState SetAsyncExc         self raise exc SystemExit    So  it allows a  thread to raise exceptions in the context of another thread  and in this way  the terminated thread can handle the termination without regularly checking an abort flag   However  according to its original source  there are some issues with this code         The exception will be raised only when executing python bytecode  If    your thread calls a native built-in blocking function  the   exception    will be raised only when execution returns to the python   code           There is also an issue if the built-in function internally calls    PyErr Clear    which would effectively cancel your pending exception     You can try to raise it again       Only exception types can be raised    safely  Exception instances are likely to cause unexpected behavior     and are thus restricted          For example  t1 raise exc TypeError  and    not t1 raise exc TypeError  blah       IMHO it s a bug  and I reported it as one  For more info     http   mail python org pipermail python-dev 2006-August 068158 html        I asked to expose this function in the built-in thread module  but    since ctypes has become a standard library  as of 2 5   and this   feature is not likely to be implementation-agnostic  it may be kept   unexposed

User · Answer

I m way late to this game  but I ve been wrestling with a similar question and the following appears to both resolve the issue perfectly for me AND lets me do some basic thread state checking and cleanup when the daemonized sub-thread exits   import threading import time import atexit  def do work       i   0    atexit register   def goodbye        print    CLEANLY  kill sub-thread with value   s  THREAD   s                 i  threading currentThread   ident      while True      print i     i    1     time sleep 1   t   threading Thread target do work  t daemon   True t start    def after timeout      print  KILL MAIN THREAD   s    threading currentThread   ident   raise SystemExit  threading Timer 2  after timeout  start     Yields   0 1 KILL MAIN THREAD  140013208254208  CLEANLY  kill sub-thread with value  2  THREAD  140013674317568

User · Answer

Start the sub thread with setDaemon True    def bootstrap  filename       mb   ModelBootstrap filename  filename    Has many Daemon threads  All get stopped automatically when main thread is stopped   t   threading Thread target bootstrap args   models conf     t setDaemon False   while True      t start       time sleep 10    I am just allowing the sub-thread to run for 10 sec  You can listen on an event to stop execution      print  Thread stopped       break

User · Answer

Asuming  that you want to have multiple threads of the same function  this is IMHO the easiest implementation to stop one by id   import time from threading import Thread  def doit id 0       doit stop 0     print  start id  d  id      while 1          time sleep 1          print              if doit stop  id              doit stop 0             break     print  end thread  d  id   t5 Thread target doit  args  5    t6 Thread target doit  args  6     t5 start     t6 start   time sleep 2  doit stop  5   kill t5 time sleep 2  doit stop  6   kill t6   The nice thing is here  you can have multiple of same and different functions  and stop them all by functionname stop  If you want to have only one thread of the function then you don t need to remember the id  Just stop  if doit stop   0

User · Answer

I m way late to this game  but I ve been wrestling with a similar question and the following appears to both resolve the issue perfectly for me AND lets me do some basic thread state checking and cleanup when the daemonized sub-thread exits   import threading import time import atexit  def do work       i   0    atexit register   def goodbye        print    CLEANLY  kill sub-thread with value   s  THREAD   s                 i  threading currentThread   ident      while True      print i     i    1     time sleep 1   t   threading Thread target do work  t daemon   True t start    def after timeout      print  KILL MAIN THREAD   s    threading currentThread   ident   raise SystemExit  threading Timer 2  after timeout  start     Yields   0 1 KILL MAIN THREAD  140013208254208  CLEANLY  kill sub-thread with value  2  THREAD  140013674317568

User · Answer

It is better if you don t kill a thread  A way could be to introduce a  try  block into the thread s cycle and to throw an exception when you want to stop the thread  for example a break return     that stops your for while        I ve used this on my app and it works

User · Answer

It is definitely possible to implement a Thread stop method as shown in the following example code   import sys import threading import time   class StopThread StopIteration       pass  threading SystemExit   SystemExit  StopThread   class Thread2 threading Thread        def stop self           self   stop   True      def  bootstrap self           if threading  trace hook is not None              raise ValueError  Cannot run thread with tracing            self   stop   False         sys settrace self   trace          super    bootstrap        def   trace self  frame  event  arg           if self   stop              raise StopThread           return self   trace   class Thread3 threading Thread        def  bootstrap self  stop thread False           def stop                nonlocal stop thread             stop thread   True         self stop   stop          def tracer                  if stop thread                  raise StopThread               return tracer         sys settrace tracer          super    bootstrap                                                                                      def main        test1   Thread2 target printer      test1 start       time sleep 1      test1 stop       test1 join       test2   Thread2 target speed test      test2 start       time sleep 1      test2 stop       test2 join       test3   Thread3 target speed test      test3 start       time sleep 1      test3 stop       test3 join     def printer        while True          print time time     1          time sleep 0 1    def speed test count 0       try          while True              count    1     except StopThread          print  Count     count   if   name         main         main     The Thread3 class appears to run code approximately 33  faster than the Thread2 class

User · Answer

It is better if you don t kill a thread  A way could be to introduce a  try  block into the thread s cycle and to throw an exception when you want to stop the thread  for example a break return     that stops your for while        I ve used this on my app and it works

User · Answer

It is better if you don t kill a thread  A way could be to introduce a  try  block into the thread s cycle and to throw an exception when you want to stop the thread  for example a break return     that stops your for while        I ve used this on my app and it works

User · Answer

Here s yet another way to do it  but with extremely clean and simple code  that works in Python 3 7 in 2021  import ctypes   def kill thread thread        quot  quot  quot      thread  a threading Thread object      quot  quot  quot      thread id   thread ident     res   ctypes pythonapi PyThreadState SetAsyncExc thread id  ctypes py object SystemExit       if res  gt  1          ctypes pythonapi PyThreadState SetAsyncExc thread id  0          print  Exception raise failure    Adapted from here  https   www geeksforgeeks org python-different-ways-to-kill-a-thread

User · Answer

You can execute your command in a process and then kill it using the process id  I needed to sync between two thread one of which  doesn   t return by itself   processIds       def executeRecord command       print command       process   subprocess Popen command  stdout subprocess PIPE      processIds append process pid      print processIds 0         Command that doesn t return by itself     process stdout read   decode  utf-8       return    def recordThread command  timeOut        thread   Thread target executeRecord  args  command        thread start       thread join timeOut       os kill processIds pop    signal SIGINT       return

User · Answer

You should never forcibly kill a thread without cooperating with it   Killing a thread removes any guarantees that try finally blocks set up so you might leave locks locked  files open  etc   The only time you can argue that forcibly killing threads is a good idea is to kill a program fast  but never single threads

User · Answer

Following workaround can be used to kill a thread   kill threads   False  def doSomething        global kill threads     while True          if kill threads              thread exit                                  thread start new thread doSomething        This can be used even for terminating threads  whose code is written in another module  from main thread  We can declare a global variable in that module and use it to terminate thread s spawned in that module   I usually use this to terminate all the threads at the program exit  This might not be the perfect way to terminate thread s but could help

User · Answer

You can kill a thread by installing trace into the thread that will exit the thread    See attached link for one possible implementation   Kill a thread in Python

User · Answer

Just to build up on  SCB s idea  which was exactly what I needed  to create a KillableThread  subclass with a customized function  from threading import Thread  Event  class KillableThread Thread       def   init   self  sleep interval 1  target None  name None  args     kwargs              super     init   None  target  name  args  kwargs          self  kill   Event           self  interval   sleep interval         print self  target       def run self           while True                Call custom function with arguments             self  target  self  args                 If no kill signal is set  sleep for the interval                If kill signal comes in while sleeping  immediately                wake up and handle             is killed   self  kill wait self  interval              if is killed                  break          print  quot Killing Thread quot        def kill self           self  kill set    if   name         main          def print msg msg           print msg       t   KillableThread 10  print msg  args   quot hello world quot        t start       time sleep 6      print  quot About to kill thread quot       t kill    Naturally  like with  SBC  the thread doesn t wait to run a new loop to stop  In this example  you would see the  quot Killing Thread quot  message printed right after the  quot About to kill thread quot  instead of waiting for 4 more seconds for the thread to complete  since we have slept for 6 seconds already   Second argument in KillableThread constructor is your custom function  print msg here   Args argument are the arguments that will be used when calling the function    quot hello world quot    here

User · Answer

from ctypes import   pthread   cdll LoadLibrary  libpthread-2 15 so   pthread pthread cancel c ulong t ident     t is your Thread object   Read the python source  Modules threadmodule c and Python thread pthread h  you can see the Thread ident is an pthread t type  so you can do anything pthread can do in python use libpthread

User · Answer

There is a library built for this purpose  stopit  Although some of the same cautions listed herein still apply  at least this library presents a regular  repeatable technique for achieving the stated goal

User · Answer

In Python  you simply cannot kill a Thread directly   If you do NOT really need to have a Thread      what you can do  instead of using the threading package   is to use the  multiprocessing package   Here  to kill a process  you can simply call the method   yourProcess terminate      kill the process    Python will kill your process  on Unix through the SIGTERM signal  while on Windows through the TerminateProcess   call   Pay attention to use it while using a Queue or a Pipe   it may corrupt the data in the Queue Pipe   Note that the multiprocessing Event and the multiprocessing Semaphore work exactly in the same way of the threading Event and the threading Semaphore respectively  In fact  the first ones are clones of the latters   If you REALLY need to use a Thread  there is no way to kill it directly  What you can do  however  is to use a  daemon thread   In fact  in Python  a Thread can be flagged as daemon   yourThread daemon   True    set the Thread as a  daemon thread    The main program will exit when no alive non-daemon threads are left  In other words  when your main thread  which is  of course  a non-daemon thread  will finish its operations  the program will exit even if there are still some daemon threads working   Note that it is necessary to set a Thread as daemon before the start   method is called   Of course you can  and should  use daemon even with multiprocessing  Here  when the main process exits  it attempts to terminate all of its daemonic child processes   Finally  please  note that sys exit   and os kill   are not choices

User · Answer

It is generally a bad pattern to kill a thread abruptly  in Python  and in any language  Think of the following cases   the thread is holding a critical resource that must be closed properly the thread has created several other threads that must be killed as well   The nice way of handling this  if you can afford it  if you are managing your own threads   is to have an exit request flag that each thread checks on a regular interval to see if it is time for it to exit  For example  import threading  class StoppableThread threading Thread        quot  quot  quot Thread class with a stop   method  The thread itself has to check     regularly for the stopped   condition  quot  quot  quot       def   init   self    args    kwargs           super StoppableThread  self    init    args    kwargs          self  stop event   threading Event        def stop self           self  stop event set        def stopped self           return self  stop event is set    In this code  you should call stop   on the thread when you want it to exit  and wait for the thread to exit properly using join    The thread should check the stop flag at regular intervals  There are cases  however  when you really need to kill a thread  An example is when you are wrapping an external library that is busy for long calls  and you want to interrupt it  The following code allows  with some restrictions  to raise an Exception in a Python thread  def  async raise tid  exctype          Raises an exception in the threads with id tid        if not inspect isclass exctype           raise TypeError  quot Only types can be raised  not instances  quot       res   ctypes pythonapi PyThreadState SetAsyncExc ctypes c long tid                                                        ctypes py object exctype       if res    0          raise ValueError  quot invalid thread id quot       elif res    1             quot if it returns a number greater than one  you re in trouble            and you should call it again with exc NULL to revert the effect quot          ctypes pythonapi PyThreadState SetAsyncExc ctypes c long tid   None          raise SystemError  quot PyThreadState SetAsyncExc failed quot    class ThreadWithExc threading Thread          A thread class that supports raising an exception in the thread from        another thread              def  get my tid self            quot  quot  quot determines this  self s  thread id          CAREFUL  this function is executed in the context of the caller         thread  to get the identity of the thread represented by this         instance           quot  quot  quot          if not self isAlive                raise threading ThreadError  quot the thread is not active quot              do we have it cached          if hasattr self   quot  thread id quot                return self  thread id            no  look for it in the  active dict         for tid  tobj in threading  active items                if tobj is self                  self  thread id   tid                 return tid            TODO  in python 2 6  there s a simpler way to do  self ident          raise AssertionError  quot could not determine the thread s id quot        def raiseExc self  exctype            quot  quot  quot Raises the given exception type in the context of this thread           If the thread is busy in a system call  time sleep            socket accept          the exception is simply ignored           If you are sure that your exception should terminate the thread          one way to ensure that it works is               t   ThreadWithExc                                    t raiseExc  SomeException               while t isAlive                    time sleep  0 1                   t raiseExc  SomeException            If the exception is to be caught by the thread  you need a way to         check that your thread has caught it           CAREFUL  this function is executed in the context of the         caller thread  to raise an exception in the context of the         thread represented by this instance           quot  quot  quot           async raise  self  get my tid    exctype     Based on Killable Threads by Tomer Filiba  The quote about the return value of PyThreadState SetAsyncExc appears to be from an old version of Python   As noted in the documentation  this is not a magic bullet because if the thread is busy outside the Python interpreter  it will not catch the interruption  A good usage pattern of this code is to have the thread catch a specific exception and perform the cleanup  That way  you can interrupt a task and still have proper cleanup

User · Answer

This is a bad answer  see the comments   Here s how to do it   from threading import         for thread in enumerate        if thread isAlive            try              thread  Thread  stop           except              print str thread getName        could not be terminated      Give it a few seconds then your thread should be stopped  Check also the thread  Thread  delete   method   I d recommend a thread quit   method for convenience  For example if you have a socket in your thread  I d recommend creating a quit   method in your socket-handle class  terminate the socket  then run a thread  Thread  stop   inside of your quit

User · Answer

You can execute your command in a process and then kill it using the process id  I needed to sync between two thread one of which  doesn   t return by itself   processIds       def executeRecord command       print command       process   subprocess Popen command  stdout subprocess PIPE      processIds append process pid      print processIds 0         Command that doesn t return by itself     process stdout read   decode  utf-8       return    def recordThread command  timeOut        thread   Thread target executeRecord  args  command        thread start       thread join timeOut       os kill processIds pop    signal SIGINT       return

User · Answer

Pieter Hintjens -- one of the founders of the   MQ-project -- says  using   MQ and avoiding synchronization primitives like locks  mutexes  events etc   is the sanest and securest way to write multi-threaded programs   http   zguide zeromq org py all Multithreading-with-ZeroMQ  This includes telling a child thread  that it should cancel its work  This would be done by equipping the thread with a   MQ-socket and polling on that socket for a message saying that it should cancel   The link also provides an example on multi-threaded python code with   MQ

User · Answer

Pieter Hintjens -- one of the founders of the   MQ-project -- says  using   MQ and avoiding synchronization primitives like locks  mutexes  events etc   is the sanest and securest way to write multi-threaded programs   http   zguide zeromq org py all Multithreading-with-ZeroMQ  This includes telling a child thread  that it should cancel its work  This would be done by equipping the thread with a   MQ-socket and polling on that socket for a message saying that it should cancel   The link also provides an example on multi-threaded python code with   MQ

User · Answer

As others have mentioned  the norm is to set a stop flag  For something lightweight  no subclassing of Thread  no global variable   a lambda callback is an option   Note the parentheses in if stop      import threading import time  def do work id  stop       print  I am thread   id      while True          print  I am thread    doing something  format id           if stop                print    Exiting loop                break     print  Thread     signing off  format id     def main        stop threads   False     workers          for id in range 0 3           tmp   threading Thread target do work  args  id  lambda  stop threads           workers append tmp          tmp start       time sleep 3      print  main  done sleeping  time to stop the threads        stop threads   True     for worker in workers          worker join       print  Finis     if   name         main         main     Replacing print   with a pr   function that always flushes  sys stdout flush    may improve the precision of the shell output    Only tested on Windows Eclipse Python3 3

User · Answer

Asuming  that you want to have multiple threads of the same function  this is IMHO the easiest implementation to stop one by id   import time from threading import Thread  def doit id 0       doit stop 0     print  start id  d  id      while 1          time sleep 1          print              if doit stop  id              doit stop 0             break     print  end thread  d  id   t5 Thread target doit  args  5    t6 Thread target doit  args  6     t5 start     t6 start   time sleep 2  doit stop  5   kill t5 time sleep 2  doit stop  6   kill t6   The nice thing is here  you can have multiple of same and different functions  and stop them all by functionname stop  If you want to have only one thread of the function then you don t need to remember the id  Just stop  if doit stop   0

User · Answer

If you are trying to terminate the whole program you can set the thread as a  daemon   see Thread daemon

[python] Is there any way to kill a Thread?

Examples related to python

Examples related to multithreading

Examples related to kill

Examples related to terminate