Op 2006-06-10, Carl J. Van Arsdall schreef <[EMAIL PROTECTED]>:
> Felipe Almeida Lessa wrote:
>> Em Sex, 2006-06-09 às 13:54 -0700, Manish Marathe escreveu:
>>
>>> On 6/9/06, Fredrik Lundh <[EMAIL PROTECTED]> wrote:
>>> Manish Marathe wrote:
>>>
>>> > I am creating threads using my self defined class which
>>> inherits the
>>> > threading.Thread class. I want to know how can I kill the
>>> threads which
>>> > are being created by the object of my self defined class.
>>>
>>> you cannot kill a thread "from the outside"; you have to
>>> design your
>>> thread tasks so they can kill themselves, when asked to do
>>> that.
>>>
>>> Thanks for the reply. So can a thread listen to an event i.e. can we
>>> send an event to the thread indicating to kill itself.
>>>
>>
>> A plain simple boolean flag will certainly do the job. For example
>>
>> def run(self):
>> self.running = True
>> while self.running:
>> blah()
>>
>> def stop(self):
>> self.running = False
>>
>>
> Well, this works if your threads are able to poll. If you had a thread
> doing lengthy IO you could end up waiting a long time until the thread
> gets an opportunity to kill itself.
>
> Are there any plans in the future to add the capability to kill threads
> from the outside?
There already is some capability, (if you mean from the outside
that one thread can kill another) However for the momemt it is
only available in the C API. But with the ctypes interface
(which will be available with the stdlib from version 2.5)
you can provide this functionality in python.
> Better yet, an interruptable thread so instead of
> using a polling loop you could send a DIE_THREAD_DIE signal or
> something. I think at present its not possible (or a really bad idea)
> to put signal handlers in threads. Anyone have thoughts on this?
It is indeed impossible to let a thread handle a signal. You can
set a handler in a thread but when a signal arrives.
But here is a class I toyed with, that can be used to throw
an exception in one thread from another. There are some
caveats however. It won't interupt C-calls. So if the
thread you want to raise the exception in, is in a C-extention,
the extention will have to finish before the exception will be
raised.
-----------------------------------------------------------------------
import ctypes
from time import sleep
SetAsyncExc = ctypes.pythonapi.PyThreadState_SetAsyncExc
class TimeOut(Exception):
pass
class Alarm(Exception):
pass
import threading
class Xthread(threading.Thread):
def start(self):
self.__original_run = self.run
self.run = self.__run
threading.Thread.start(self)
def __run(self):
self._thrd_id = threading._get_ident()
try:
self.__original_run()
finally:
self.run = self.__original_run
def throw(self, excpt):
Nr = SetAsyncExc(self._thrd_id, ctypes.py_object(excpt))
while Nr > 1:
SetAsyncExc(self._thrd_id, None)
sleep(0.1)
Nr = SetAsyncExc(self._thrd_id, ctypes.py_object(excpt))
def alarm(self, tm):
alrm = threading.Timer(tm, self.throw, (TimeOut,))
alrm.start()
return alrm
if __name__ == "__main__":
import os
from random import randint
class Continue(Xthread):
def run(self):
self.id = os.getpid()
print self.id, self._thrd_id, "Begin"
i = 0
try:
for _ in xrange(randint(0,20)):
for e in xrange(4 * 100000):
i = i + e
print self.id, self._thrd_id, "Finished"
except Alarm:
print self.id, self._thrd_id, "Interupted"
lst = [Continue() for _ in xrange(10)]
for T in lst:
T.start()
try:
sleep(10)
finally:
for T in lst:
T.throw(Alarm)
--
Antoon Pardon
--
http://mail.python.org/mailman/listinfo/python-list
