Vega strike Python Modules doc: _Condition Class Reference

All Data Structures Namespaces Files Functions Variables

Inheritance diagram for _Condition:

Public Member Functions
def	__init__

def	__repr__

def	wait

def	notify

def	notifyAll

Public Member Functions inherited from _Verbose
def	__init__

def	__init__

Data Fields
	acquire

	release

Detailed Description

Definition at line 138 of file threading.py.

Constructor & Destructor Documentation

def __init__	(	self,
		lock = `None`,
		verbose = `None`
	)

Definition at line 140 of file threading.py.

References _Condition.__lock, and threading.RLock().

 
     def __init__(self, lock=None, verbose=None):
         _Verbose.__init__(self, verbose)
         if lock is None:
             lock = RLock()
         self.__lock = lock
         # Export the lock's acquire() and release() methods
         self.acquire = lock.acquire
         self.release = lock.release
         # If the lock defines _release_save() and/or _acquire_restore(),
         # these override the default implementations (which just call
         # release() and acquire() on the lock).  Ditto for _is_owned().
         try:
             self._release_save = lock._release_save
         except AttributeError:
             pass
         try:
             self._acquire_restore = lock._acquire_restore
         except AttributeError:
             pass
         try:
             self._is_owned = lock._is_owned
         except AttributeError:
             pass
         self.__waiters = []

Member Function Documentation

def __repr__ ( self)

Definition at line 165 of file threading.py.

References _Condition.__lock, and _Condition.__waiters.

 
     def __repr__(self):
         return "<Condition(%s, %d)>" % (self.__lock, len(self.__waiters))

def notify	(	self,
		n = `1`
	)

Definition at line 223 of file threading.py.

References _Condition.__waiters, _Condition._is_owned, _Verbose._note(), and threading.currentThread().

 
     def notify(self, n=1):
         me = currentThread()
         assert self._is_owned(), "notify() of un-acquire()d lock"
         __waiters = self.__waiters
         waiters = __waiters[:n]
         if not waiters:
             if __debug__:
                 self._note("%s.notify(): no waiters", self)
             return
         self._note("%s.notify(): notifying %d waiter%s", self, n,
                    n!=1 and "s" or "")
         for waiter in waiters:
             waiter.release()
             try:
                 __waiters.remove(waiter)
             except ValueError:
                 pass

def wait	(	self,
		timeout = `None`
	)

Definition at line 181 of file threading.py.

References _Condition._acquire_restore, threading._allocate_lock, _Condition._is_owned, _Verbose._note(), _Condition._release_save, threading._sleep, threading._time, threading.currentThread(), and sre_parse.min.

 
     def wait(self, timeout=None):
         me = currentThread()
         assert self._is_owned(), "wait() of un-acquire()d lock"
         waiter = _allocate_lock()
         waiter.acquire()
         self.__waiters.append(waiter)
         saved_state = self._release_save()
         try:    # restore state no matter what (e.g., KeyboardInterrupt)
             if timeout is None:
                 waiter.acquire()
                 if __debug__:
                     self._note("%s.wait(): got it", self)
             else:
                 # Balancing act:  We can't afford a pure busy loop, so we
                 # have to sleep; but if we sleep the whole timeout time,
                 # we'll be unresponsive.  The scheme here sleeps very
                 # little at first, longer as time goes on, but never longer
                 # than 20 times per second (or the timeout time remaining).
                 endtime = _time() + timeout
                 delay = 0.0005 # 500 us -> initial delay of 1 ms
                 while 1:
                     gotit = waiter.acquire(0)
                     if gotit:
                         break
                     remaining = endtime - _time()
                     if remaining <= 0:
                         break
                     delay = min(delay * 2, remaining, .05)
                     _sleep(delay)
                 if not gotit:
                     if __debug__:
                         self._note("%s.wait(%s): timed out", self, timeout)
                     try:
                         self.__waiters.remove(waiter)
                     except ValueError:
                         pass
                 else:
                     if __debug__:
                         self._note("%s.wait(%s): got it", self, timeout)
         finally:
             self._acquire_restore(saved_state)

Public Member Functions

Data Fields

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation