lsst.utils.multithreading.SharedData.SharedData Class Reference

Inheritance diagram for lsst.utils.multithreading.SharedData.SharedData:

Public Member Functions
def	__init__
def	__enter__
def	__exit__
def	__getattribute__
def	__setattr__
def	initData
def	dir

Public Attributes
	acquire
	release
	notify
	notifyAll
	wait

Private Attributes
	_d
	_cond
	_is_owned
	_lockOnRead

Detailed Description

a lock-protected container for data that can be shared amongst threads.

This container holds data that is intended to be shared amongst multiple
threads.  In order to update or (optionally) examine the data, one must
first aquire the lock associated with the container.

This container also behaves like a threading.Container, via its 
wait(), notify(), and notifyAll() functions.  Also like Condition, 
acquire() is reentrant.  

SharedData instances may be used with the with statement:

  sd = SharedData()
  with sd:
      sd.blah = 1

The with statement will acquire the lock and ensure that it is released
when its block is exited.  

Definition at line 27 of file SharedData.py.

Constructor & Destructor Documentation

def lsst.utils.multithreading.SharedData.SharedData.__init__	(		self,
			needLockOnRead = True,
			data = None,
			cond = None
	)

create and initialize the shared data
@param needLockOnRead   if true (default), acquiring the lock will 
      be needed when reading the data.  This is recommended
      if the data items are anything but primitive types;
      otherwise, a compound data item (e.g. of type dict)
      could be updated without acquiring a lock.  
@param data   a dictionary of data to initialize the container with.
      This is done by calling initData().  Set this value to
      False when calling from a subclass constructor; this
      will allow any non-protected attributes to be set via
      the subclass's constructor.  If None is given (default),
      it is assumed that all new attributes will be considered
      protected data.
@param cond   Reuse this existing Condition instance to protect this
        container

Definition at line 49 of file SharedData.py.

    def __init__(self, needLockOnRead=True, data=None, cond=None):
        """
        create and initialize the shared data
        @param needLockOnRead   if true (default), acquiring the lock will 
                      be needed when reading the data.  This is recommended
                      if the data items are anything but primitive types;
                      otherwise, a compound data item (e.g. of type dict)
                      could be updated without acquiring a lock.  
        @param data   a dictionary of data to initialize the container with.
                      This is done by calling initData().  Set this value to
                      False when calling from a subclass constructor; this
                      will allow any non-protected attributes to be set via
                      the subclass's constructor.  If None is given (default),
                      it is assumed that all new attributes will be considered
                      protected data.
        @param cond   Reuse this existing Condition instance to protect this
                        container
        """
        self._d = {}
        if cond is None:
            cond = threading.Condition()
        self._cond = cond

        # behave like a Condition
        self.acquire   = cond.acquire
        self.release   = cond.release
        self.notify    = cond.notify
        self.notifyAll = cond.notifyAll
        self.wait      = cond.wait
        self._is_owned = cond._is_owned

        self._lockOnRead = needLockOnRead

        if isinstance(data, dict):
            self.initData(data)
        if data is None:
            self._d["__"] = True