什么是实现线程最大执行时间的最佳方法（在python / gtk中）？

Question

What is the best known practice to implement a thread job timeout (ie: kill the job after a maximum of X seconds) ? I wrote the following python code. I read a lot of different way to implement this but I'm a little lost... Do I have to do this with a timer ? or by counting in add_timeout callback ?

as a side note , usage of thread.join(timeout) is pretty limited within gtk/threaded application as it blocks the main thread ?

Thanks !!

Note: I'm pretty new to python/threading

#!/usr/bin/python

import time
import threading
import gobject
import gtk
import glib
gobject.threads_init()


class myui():
    def __init__(self):
        interface = gtk.Builder()
        interface.add_from_file("myui.glade")
        interface.connect_signals(self)

        self.spinner = interface.get_object('spinner1')         

    def bg_work1(self):
        print "work has started"
        # simulates some work
        time.sleep(5)
        print "work has finished"

    def startup(self):
        thread = threading.Thread(target=self.bg_work1)
        thread.start()

        # work started. Now while the work is being done I want
        # a spinner to rotate
        self.spinner.start()
        print "spinner started"

        #thread.join() # I wanna wait for the job to be finished while the spinner spins.
                                    # but this seems to block the main thread, and so the gui doesn't shows up !

        glib.timeout_add(100, self.check_job, thread, 5)

    def check_job(self, thread, timeout):
        #print 'check job called'

        if not thread.isAlive():
                print 'is not alive anymore'
                self.spinner.stop()
                return False
        return True


if __name__ == "__main__":

    app = myui()
    app.startup()

    print "gtk main loop starting !"

    gtk.main()
    print "gtk main loop has stopped !"

Answer 1

Your code seems pretty good, the only thing missing is to use and evaluate a timeout point:

    glib.timeout_add(100, self.check_job, thread, time.time() + 5)

def check_job(self, thread, timeout):
    #print 'check job called'

    if not thread.isAlive():
            print 'is not alive anymore'
            self.spinner.stop()
            return False
    if time.time() > timeout:
            print 'job timed out'
            self.spinner.stop()
            return False
    return True

However, this does not kill your worker thread after the timeout, so it will still be running. I am not aware of a method to forcibly terminate a Python thread. You would have to split your work and check for timeout in the worker thread, so it can gracefully terminate.