[python-win32] Restart/re-run a thread

[Jacob Kruger]

Thanks.

What have also found that seems nice/usable enough is to sort of implement a class that inherits from threading.Thread, and then it runs the class's functionality in the threaded background, and you can define other functions and variables to check state if you want to - something like the following - off the top of my head:
#---start of code---
 import threading, time
class myClass(threading.Thread):
  counter = -1
  def __init__(self):
    self.counter = 0
    threading.Thread.__init__(self)

  def getCount(self):
    return self.counter

  def run(self):
    while self.counter < 60:
      self.counter += 1
      time.sleep(1)
#---end of code---

The partial point is this one will be initiated, but when you then tell your instance of the class/object to start(), it sort of automatically tells itself to run(), and you can call the getCount() function to get the value of it's internal counter variable, etc. - simple example, but seems to work well enough, if you get my/the drift, and, what have pretty much found all over the 'net is that you get told not to try destroy anything manually/yourself, but anyway.

Stay well

Jacob Kruger
Blind Biker
Skype: BlindZA
'...fate had broken his body, but not his spirit...'

  ----- Original Message ----- 
  From: geoff 
  To: Jacob Kruger 
  Cc: python-win32 at python.org 
  Sent: Thursday, October 27, 2011 3:47 PM
  Subject: Re: [python-win32] Restart/re-run a thread


  The python docs are pretty clear that there is no way to external stop a thread and this was a design decision.


  Typically, I have used a threading.Event to control the actions of the worker threads from a loop in the main program.


  Setup each worker thread as a loop using the event.wait() method to block the loop.   When you are ready for all of the threads to proceed, use the controller thread and event.set().  All of the worker threads will exit the blocking state of their loop and proceed with execution.  Once finished, they return to the  event.wait() mode.  


  To stop the threads, I typically use another thread.Event object called "keepgoing" and test for that at the top of the worker threads processing loop.  When the threads have finished processing and you want them to stop, you can set the keepgoing event to false.




  The example below is from memory, so be careful;


  keepgoing = threading.Event()
  keepgoing.set()   # evaluates to True


  startprocess = threading.Event()
  startprocess.clear()  # evaluates to False


  class worker(threading.Thread):
      def __init__(self, keepgoing, startprocess):
           while keepgoing:
                if startprocess:
                         ... do someprocessing here
                else:
                     startprocess.wait()            #blocks the thread waiting for the event to be set.




  Note that if you need to pass objects into the worker thread, I would suggest placing in a collections.deque.  One the startprocess is set, you can use deque.pop() to take the object out of the deque in a thread safe way.


  Hope this helps.


  BTW, I am not sure if this is for education purposes or for production, but debugging threads is REALLY HARD, so make sure this is something you really need to do.



-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-win32/attachments/20111027/39559b54/attachment-0001.html>