class NameLock(object): """a proxy for an RLock object that is stored in a name based registry. Multiple threads can get a reference to the same RLock based on the name alone, and synchronize operations related to that name. """ locks = util.WeakValuedRegistry() class NLContainer(object): def __init__(self, reentrant): if reentrant: self.lock = _threading.RLock() else: self.lock = _threading.Lock() def __call__(self): return self.lock def __init__(self, identifier=None, reentrant=False): if identifier is None: self._lock = NameLock.NLContainer(reentrant) else: self._lock = NameLock.locks.get(identifier, NameLock.NLContainer, reentrant) def acquire(self, wait=True): return self._lock().acquire(wait) def release(self): self._lock().release()
class Synchronizer(object): """a read-many/single-writer synchronizer which globally synchronizes on a given string name.""" conditions = util.WeakValuedRegistry() def __init__(self, identifier=None, use_files=False, lock_dir=None, digest_filenames=True): if not has_flock: use_files = False if use_files: syncs = Synchronizer.conditions.sync_get( "file_%s" % identifier, lambda: util.ThreadLocal(creator=lambda: FileSynchronizer( identifier, lock_dir, digest_filenames))) self._get_impl = lambda: syncs.get() else: condition = Synchronizer.conditions.sync_get( "condition_%s" % identifier, lambda: ConditionSynchronizer(identifier)) self._get_impl = lambda: condition def release_read_lock(self): self._get_impl().release_read_lock() def acquire_read_lock(self, wait=True): return self._get_impl().acquire_read_lock(wait=wait) def acquire_write_lock(self, wait=True): return self._get_impl().acquire_write_lock(wait=wait) def release_write_lock(self): self._get_impl().release_write_lock()
def __init__(self, identifier=None, reentrant=False): if identifier is None: self._lock = NameLock.NLContainer(reentrant) else: self._lock = NameLock.locks.get(identifier, NameLock.NLContainer, reentrant) def acquire(self, wait=True): return self._lock().acquire(wait) def release(self): self._lock().release() _synchronizers = util.WeakValuedRegistry() def _synchronizer(identifier, cls, **kwargs): return _synchronizers.sync_get((identifier, cls), cls, identifier, **kwargs) def file_synchronizer(identifier, **kwargs): if not has_flock or 'lock_dir' not in kwargs: return mutex_synchronizer(identifier) else: return _synchronizer(identifier, FileSynchronizer, **kwargs) def mutex_synchronizer(identifier, **kwargs):