On Feb 22, 12:08 pm, mark <[EMAIL PROTECTED]> wrote:
> On 21 Feb 2007 16:10:51 -0800, placid <[EMAIL PROTECTED]> wrote:
>
> > On Feb 22, 10:20 am, mark <[EMAIL PROTECTED]> wrote:
> > > On 21 Feb 2007 14:47:50 -0800, placid <[EMAIL PROTECTED]> wrote:
>
> > > > On Feb 22, 3:23 am, mark <[EMAIL PROTECTED]> wrote:
> > > > > On 20 Feb 2007 21:26:18 -0800, placid <[EMAIL PROTECTED]> wrote:
>
> > > > > > On Feb 21, 4:21 pm, "placid" <[EMAIL PROTECTED]> wrote:
> > > > > > > On Feb 21, 4:12 pm, mark <[EMAIL PROTECTED]> wrote:
> > > > > > > > On 20 Feb 2007 20:47:57 -0800, placid <[EMAIL PROTECTED]> wrote:
> > > > > > > > > On Feb 21, 3:08 pm, mark <[EMAIL PROTECTED]> wrote:
> > > > > > > > > > Right now I have a thread that  sleeps for sometime and 
> > > > > > > > > > check if an
> > > > > > > > > > event has happened and go back to sleep. Now instead I want 
> > > > > > > > > > the thread
> > > > > > > > > > to sleep until the event has occured process the event and 
> > > > > > > > > > go back to sleep
>
> > > > > > > > > > class eventhndler(threading.Thread):
> > > > > > > > > >     def __init__(self):
> > > > > > > > > >         threading.Thread.__init__(self)
> > > > > > > > > >     def run(self):
> > > > > > > > > >         while True:
> > > > > > > > > >             time.sleep(SLEEPTIME)
> > > > > > > > > >             ''''do event stuff'''
>
> > > > > > > > > The way i would do this is by using an threading.Event (
> > > > > > > > >http://docs.python.org/lib/event-objects.html)
>
> > > > > > > > > <code>
>
> > > > > > > > > class eventhandler(threading.Thread):
> > > > > > > > >     def __init__(self):
> > > > > > > > >         threading.Thread.__init__(self)
> > > > > > > > >         self.event = threading.Event()
> > > > > > > > >     def run:
> > > > > > > > >         while True:
> > > > > > > > >             # block until some event happens
> > > > > > > > >             self.event.wait()
> > > > > > > > >             """ do stuff here """
> > > > > > > > >             self.event.clear()
> > > > > > > > > </code>
>
> > > > > > > > > the way to use this is to get the main/separate thread to 
> > > > > > > > > set() the
> > > > > > > > > event object.
>
> > > > > > > > Can you give an example of how to get the main threead to set 
> > > > > > > > teh event object?
> > > > > > > > this is exactly what i wanted to do!
> > > > > > > > thanks a lot!
> > > > > > > > mark>
> > > > > > oops I've miss-typed the thread variable name the following should
> > > > > > work
>
> > > > > > <code>
> > > > > > if __name__ == "__main__":
> > > > > >     evtHandlerThread = eventhandler()
> > > > > >     evtHandlerThread.start()
>
> > > > > >     # do something here #
> > > > > >     evtHandlerThread.event.set()
>
> > > > > >     # do more stuff here #
> > > > > >     evtHandlerThread.event.set()
>
> > > > > > </code>
>
> > > > > Can I have the same thread process two or more events? Can you tell
> > > > > how to do this? The code you gave is waiting on one event right. How
> > > > > can I do it for more events?
> > > > > thanks a lot!
> > > > > mark
>
> > > > I don't think a thread can block on more than one event at a time. But
> > > > you can make it block on more then one event one at a time.
>
> > > > <code>
>
> > > > class eventhandler(threading.Thread):
> > > >    def __init__(self):
> > > >        threading.Thread.__init__(self)
> > > >        self.events = [threading.Event(), threading.Event()]
> > > >        self.currentEvent = None
> > > >    def run:
> > > >        while True:
> > > >            for event in self.events:
> > > >                self.currentEvent = event
> > > >                # block until some event happens
> > > >                self.currentEvent.wait()
> > > >                """ do stuff here """
> > > >                self.currentEvent.clear()
>
> > > > if __name__ == "__main__":
> > > >     evtHandlerThread = eventhandler()
> > > >     evtHandlerThread.start()
>
> > > >     # do something here #
> > > >     evtHandlerThread.currentEvent.set()
>
> > > >     # do more stuff here #
> > > >     evtHandlerThread.currentEvent.set()
>
> > > > </code>
>
> > > > what the thread does is sequentially waits for two events to happen
> > > > and then execute the same code. You could change this code to perform
> > > > different functions for different event objects.
>
> > > Once the thread starts it is going to wait on the event that is the
> > > first element of the list right?  This would mean :
>
> > This is correct.
>
> > > evtHandlerThread.currentEvent.set(): that I have only one event right?
>
> > this means that the current event occurred.
>
> > > Can you explain how I can have different event objects. I dont see how
> > > I can do different functinos for same event.
>
> > > Thanks a lot!
>
> > > mark
>
> > To run different functions for the same event is easy, just write a
> > wrapper class around threading.event() and include some method that
> > you will run and assign this to different functions for each
> > EventWrapper.
>
> > <code>
>
> > class EventWrapper():
> >     def __init__(self,work ):
> >          self.event = threading.Event()
> >          self.eventWork = work
>
> >    def wait(self):
> >         self.event.wait()
>
> >    def clear(self)
> >         self.event.clear()
>
> >     def eventWork(self):
> >         print "no work"
>
> > class eventhandler(threading.Thread):
> >      def __init__(self, events = None):
> >          threading.Thread.__init__(self)
> >          self.events = events
> >          self.currentEvent = None
> >      def run:
> >          while True:
> >              if self.events:
> >                  for event in self.events:
> >                      self.currentEvent = event
> >                      # block until the current event happens
> >                      self.currentEvent.wait()
> >                      self.currentEvent.eventWork()
> >                      self.currentEvent.clear()
>
> > def eventOneWork():
> >     # do some event 1 specific work here
>
> > def eventTwoWork():
> >     # do some event 2 specific work here
>
> > if __name__ == "__main__":
> >       events = [EventWrapper(eventOneWork),EventWrapper(eventTwoWork)]
>
> >       evtHandlerThread = eventhandler(events)
> >       evtHandlerThread.start()
>
> >       # do something here #
> >       evtHandlerThread.currentEvent.set()
> >       # do more stuff here #
> >       evtHandlerThread.currentEvent.set()
>
> > </code>
>
> > So you have a EventWrapper class that now contains the Event object
> > and a workEvent() method which is assigned to a function you create.
>
> THanks  a lot! Does this have to have event1 and event2 occur in
> sequence? Will this still work even if only event2 occurs and event1
> never occurs?
> thanks
> mark

well if event1 never occurs then it will block/wait until forever and
even if event2 has occurred you never know about it until event1
occurs. You can introduce a timeout to the wait() call on the event
object which says, "block X seconds or until event happens (someone
calls the set method)" so even if event1 doesnt occur you will execute
event1.eventWork() because the timeout occurred. The way to fix this
is before you call the eventWork() method check if the event has
occurred via the isSet() method of Event objects.

http://docs.python.org/lib/event-objects.html

Cheers

-- 
http://mail.python.org/mailman/listinfo/python-list

Reply via email to