Kill python thread using os

Question

I've already asked similar question many times, but still can't find appropriate solution.

I have and external function, that could run in some cases very long. I want to interrupt it after, say, 30 seconds.

How do I do that?

1. Threads are good, but I can't stope them (i don't have access to external function's code)
2. Multiprocessing is also not an option, because I run site under mod_wsgi.

Are there any reliable ways to stop the thread? Maybe using os.system or os.kill. If yes, then how?

External function only performs some caclulations, no network connections or file openings. So, I just need to stop process and clean up.

My code (actually was taken from some source):

def time_limit(timeout):
    def internal(function):
        def internal2(*args, **kw):
            class MyThread(threading.Thread):
                def __init__(self):
                    threading.Thread.__init__(self)
                    self.result = None
                    self.error = None

                def run(self):
                    try:
                        self.result = function(*args, **kw) # this is external
                    except Exception as e:
                        self.error = e

                def _stop(self):
                    if self.isAlive():
                        threading.Thread._Thread__stop(self)

            c = MyThread()
            c.start()
            c.join(timeout)
            counter = 0
            if c.isAlive():
                c._stop()
                raise TimeoutException
            if c.error:
                raise c.error
            return c.result
        return internal2
    return internal

Answer 1

You can't kill thread, but you can kill a process. If you can use processes instead threads, you can use multithreading module. Process can be terminated from parent application.

If you describe your task in more detail, maybe I can help more.

Answer 2

No, there is no way to externally stop a thread. A thread is under complete control of the process that spawned it, killing it externally would mean you'd have to mess with process memory, which would usually mean that you render the process dysfunctional; what you'd usually do is handling messages in some form that allows threads to terminate on some external impulse themselves.

Answer 3

It may not be the best way to terminate a thread, but this answer provides a way to kill a thread. Beware that you may also need to implement a way for threads to be unkillable in critical sections of their code.

---

For your convenience, the code and usage example are included below:

import threading
import sys

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()

################################################################################

import time

def main():
    test = Thread2(target=printer)
    test.start()
    time.sleep(1)
    test.stop()
    test.join()

def printer():
    while True:
        print(time.time() % 1)
        time.sleep(0.1)

if __name__ == '__main__':
    main()

The Thread3 class appears to run code approximately 33% faster than the Thread2 class.

Answer 4

you can perform terminal commands using os.system this will allow you to have terminal control from within the program. if you want to

import os
os.system("terminal command goes here")

for linux read up on this: https://www.digitalocean.com/community/tutorials/how-to-use-ps-kill-and-nice-to-manage-processes-in-linux

look into pthread_kill() Stack exchange - how to kill a thtread

for windows: http://forum.thewindowsclub.com/windows-tips-tutorials-articles/29463-kill-processes-using-command-prompt-windows-7-8-a.html

for mac: http://www.chriswrites.com/how-to-view-and-kill-processes-using-the-terminal-in-mac-os-x/

ALTERNATIVELY:

import signal
signum = signal.getsignal(c)
signal.siginterrupt(signum, flag)

OR:

import os
sigID = c.get_ident 
os.system("kill -SIGKILL " + sigID)

signal doc page there is also some timer functions you can set as well.

additional info on python threading: https://docs.python.org/2/library/thread.html