我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用threading.RLock()。
def __init__(self): self._poller_name = 'IOCP' self.iocp = win32file.CreateIoCompletionPort(win32file.INVALID_HANDLE_VALUE, None, 0, 0) self._timeouts = [] self.async_poller = _AsyncPoller(self) self.cmd_rsock, self.cmd_wsock = _AsyncPoller._socketpair() self.cmd_wsock.setblocking(0) self.cmd_rsock = AsyncSocket(self.cmd_rsock) self.cmd_rsock._notifier = self self.cmd_rsock._register() self.cmd_rsock_buf = win32file.AllocateReadBuffer(128) self.cmd_rsock._read_overlap.object = self.cmd_rsock_recv err, n = win32file.WSARecv(self.cmd_rsock._fileno, self.cmd_rsock_buf, self.cmd_rsock._read_overlap, 0) if err and err != winerror.ERROR_IO_PENDING: logger.warning('WSARecv error: %s', err) self._lock = threading.RLock() self._polling = False
def __init__(self, url, timeout=None, num_workers=10, **kwargs): """ Initialise an instance. :param url: The root URL to use for scraping. :param timeout: The timeout, in seconds, to be applied to requests. This defaults to ``None`` (no timeout specified). :param num_workers: The number of worker threads you want to do I/O, This defaults to 10. :param kwargs: Passed to the superclass. """ super(SimpleScrapingLocator, self).__init__(**kwargs) self.base_url = ensure_slash(url) self.timeout = timeout self._page_cache = {} self._seen = set() self._to_fetch = queue.Queue() self._bad_hosts = set() self.skip_externals = False self.num_workers = num_workers self._lock = threading.RLock() # See issue #45: we need to be resilient when the locator is used # in a thread, e.g. with concurrent.futures. We can't use self._lock # as it is for coordinating our internal threads - the ones created # in _prepare_threads. self._gplock = threading.RLock()
def __init__(self, devmgr, identifier, label, softwareProfile, compositeDevice, execparams, propertydefs=(),loggerName=None): if not loggerName and label: loggerName = label.rsplit("_", 1)[0] resource.Resource.__init__(self, identifier, execparams, propertydefs, loggerName=loggerName) self._log.debug("Initializing Device %s %s %s %s", identifier, execparams, propertydefs, loggerName) self._label = label self._name = label self._softwareProfile = softwareProfile self._devmgr = devmgr self._devMgr = containers.DeviceManagerContainer(devmgr) self._domMgr = containers.DomainManagerContainer(devmgr._get_domMgr()) self._compositeDevice = compositeDevice self._capacityLock = threading.RLock() self._idm_publisher = None self._cmdLock = threading.RLock() self._allocationCallbacks = {} self.__initialize()
def _checkLevel(level): if isinstance(level, int): rv = level elif str(level) == level: if level not in _levelNames: raise ValueError("Unknown level: %r" % level) rv = _levelNames[level] else: raise TypeError("Level not an integer or a valid string: %r" % level) return rv #--------------------------------------------------------------------------- # Thread-related stuff #--------------------------------------------------------------------------- # #_lock is used to serialize access to shared data structures in this module. #This needs to be an RLock because fileConfig() creates and configures #Handlers, and so might arbitrary user threads. Since Handler code updates the #shared dictionary _handlers, it needs to acquire the lock. But if configuring, #the lock would already have been acquired - so we need an RLock. #The same argument applies to Loggers and Manager.loggerDict. #
def __new__(cls, *args, **kw): self = object.__new__(cls) key = '_local__key', 'thread.local.' + str(id(self)) object.__setattr__(self, '_local__key', key) object.__setattr__(self, '_local__args', (args, kw)) object.__setattr__(self, '_local__lock', RLock()) if (args or kw) and (cls.__init__ is object.__init__): raise TypeError("Initialization arguments are not supported") # We need to create the thread dict in anticipation of # __init__ being called, to make sure we don't call it # again ourselves. dict = object.__getattribute__(self, '__dict__') current_thread().__dict__[key] = dict return self
def __init__(self, filename, table_name='data', fast_save=False, **options): """ :param filename: filename for database (without extension) :param table_name: table name :param fast_save: If it's True, then sqlite will be configured with `"PRAGMA synchronous = 0;" <http://www.sqlite.org/pragma.html#pragma_synchronous>`_ to speedup cache saving, but be careful, it's dangerous. Tests showed that insertion order of records can be wrong with this option. """ self.filename = filename self.table_name = table_name self.fast_save = fast_save #: Transactions can be commited if this property is set to `True` self.can_commit = True self.serializer = Serializer() self._bulk_commit = False self._pending_connection = None self._lock = threading.RLock() with self.connection() as con: con.execute("create table if not exists `%s` (key PRIMARY KEY, value)" % self.table_name)
def __init__(self,resultfilename,logger=logger('detourResultWriter.log')): self.lock = threading.RLock() self.resultfilename = resultfilename #There could be some old garbage result file with same name, remove it if os.path.exists(self.resultfilename): os.remove(self.resultfilename) self.logger=logger self.peers = [] self.rib_name=None self.rib_time='NULL' self.num_entries=0 self.num_def_detours=0 self.num_poss_detours=0 self.ProcessedRibData=[] #List to hold summarized information about result file self.ProcessedPeerData=[] #List to hold summarized information per peer self.ProcessedPeerInfo=[] #List to hold peer location info
def __init__(self, host, host_distance, session): self.host = host self.host_distance = host_distance self._session = weakref.proxy(session) self._lock = RLock() self._conn_available_condition = Condition() log.debug("Initializing new connection pool for host %s", self.host) core_conns = session.cluster.get_core_connections_per_host(host_distance) self._connections = [session.cluster.connection_factory(host.address) for i in range(core_conns)] self._keyspace = session.keyspace if self._keyspace: for conn in self._connections: conn.set_keyspace_blocking(self._keyspace) self._trash = set() self._next_trash_allowed_at = time.time() self.open_count = core_conns log.debug("Finished initializing new connection pool for host %s", self.host)
def __init__(self, cluster, timeout, schema_event_refresh_window, topology_event_refresh_window, status_event_refresh_window, schema_meta_enabled=True, token_meta_enabled=True): # use a weak reference to allow the Cluster instance to be GC'ed (and # shutdown) since implementing __del__ disables the cycle detector self._cluster = weakref.proxy(cluster) self._connection = None self._timeout = timeout self._schema_event_refresh_window = schema_event_refresh_window self._topology_event_refresh_window = topology_event_refresh_window self._status_event_refresh_window = status_event_refresh_window self._schema_meta_enabled = schema_meta_enabled self._token_meta_enabled = token_meta_enabled self._lock = RLock() self._schema_agreement_lock = Lock() self._reconnection_handler = None self._reconnection_lock = RLock() self._event_schedule_times = {}
def __init__(self, url, timeout=None, num_workers=10, **kwargs): """ Initialise an instance. :param url: The root URL to use for scraping. :param timeout: The timeout, in seconds, to be applied to requests. This defaults to ``None`` (no timeout specified). :param num_workers: The number of worker threads you want to do I/O, This defaults to 10. :param kwargs: Passed to the superclass. """ super(SimpleScrapingLocator, self).__init__(**kwargs) self.base_url = ensure_slash(url) self.timeout = timeout self._page_cache = {} self._seen = set() self._to_fetch = queue.Queue() self._bad_hosts = set() self.skip_externals = False self.num_workers = num_workers self._lock = threading.RLock()
def __init__(self, hci_thread, cb_thread): self.connections = set() self.hci = hci_thread self.cb_thread = cb_thread self.is_initiating = False self.lock = RLock() def _is_le_connection_event_filter(packet): return packet.getlayer(HCI_LE_Meta_Connection_Complete) is not None self.cb_thread.add_callback( _is_le_connection_event_filter, self.handle_connection_packet) def _is_disconnection_event_filter(packet): return packet.getlayer(HCI_Event_Disconnection_Complete) is not None self.cb_thread.add_callback( _is_disconnection_event_filter, self.handle_disconnection_packet)
def __init__(self, workers, queue_size=1024, probe=None, keep_order=False): if probe is None: probe = {} self.workers = workers self.head_queue = _make_q(queue_size) self.probe = probe self.keep_order = keep_order self.worker_groups = [] self.probe.update({ 'worker_groups': self.worker_groups, 'probe_lock': threading.RLock(), 'in': 0, 'out': 0, }) self.make_worker_groups()
def __init__(self, host=None, port=None, username=None, password=None, use_tls=None, fail_silently=False, use_ssl=None, timeout=None, ssl_keyfile=None, ssl_certfile=None, **kwargs): super(EmailBackend, self).__init__(fail_silently=fail_silently) self.host = host or settings.EMAIL_HOST self.port = port or settings.EMAIL_PORT self.username = settings.EMAIL_HOST_USER if username is None else username self.password = settings.EMAIL_HOST_PASSWORD if password is None else password self.use_tls = settings.EMAIL_USE_TLS if use_tls is None else use_tls self.use_ssl = settings.EMAIL_USE_SSL if use_ssl is None else use_ssl self.timeout = settings.EMAIL_TIMEOUT if timeout is None else timeout self.ssl_keyfile = settings.EMAIL_SSL_KEYFILE if ssl_keyfile is None else ssl_keyfile self.ssl_certfile = settings.EMAIL_SSL_CERTFILE if ssl_certfile is None else ssl_certfile if self.use_ssl and self.use_tls: raise ValueError( "EMAIL_USE_TLS/EMAIL_USE_SSL are mutually exclusive, so only set " "one of those settings to True.") self.connection = None self._lock = threading.RLock()
def _checkLevel(level): if isinstance(level, (int, long)): rv = level elif str(level) == level: if level not in _levelNames: raise ValueError("Unknown level: %r" % level) rv = _levelNames[level] else: raise TypeError("Level not an integer or a valid string: %r" % level) return rv #--------------------------------------------------------------------------- # Thread-related stuff #--------------------------------------------------------------------------- # #_lock is used to serialize access to shared data structures in this module. #This needs to be an RLock because fileConfig() creates and configures #Handlers, and so might arbitrary user threads. Since Handler code updates the #shared dictionary _handlers, it needs to acquire the lock. But if configuring, #the lock would already have been acquired - so we need an RLock. #The same argument applies to Loggers and Manager.loggerDict. #
def __init__(self, name='', resource_cls=Resource, policy={}): # sets resource pool policy overriding defaults self.name=name self.__resource_cls=resource_cls self.__available_resources=list() self.__awaiting=OrderedDict() self.__reserved=OrderedDict() self.__inuse_resources=list() self.__id=self.__pool_id_sequence() #self.mutex = threading.RLock() #self.__ticket_sequence=Sequence("ResourcePool.%s" % (resource_cls.__name__, )) if self.__allow_set_policy: self.__policy=MergedChainedDict(policy, self.__policy) else: #self.__lock.release() raise ResourcePoolError("ResourcePool already in use, cannot set_policy")
def __init__(self, write_retries, use_sandbox=False, **kwargs): super(GatewayConnection, self).__init__(**kwargs) self.server = ( 'gateway.push.apple.com', 'gateway.sandbox.push.apple.com')[use_sandbox] self.port = 2195 if self.enhanced == True: # start error-response monitoring thread self._last_activity_time = time.time() self._working = False self._send_lock = threading.RLock() self._error_response_handler_worker = None self._response_listener = None self._error_listener = None self.write_retries = write_retries self._sent_notifications = collections.deque(maxlen=SENT_BUFFER_QTY)
def __init__(self, iocp_notifier): self._poller_name = 'select' self._fds = {} self._events = {} self._terminate = False self.rset = set() self.wset = set() self.xset = set() self.iocp_notifier = iocp_notifier self.cmd_rsock, self.cmd_wsock = _AsyncPoller._socketpair() self.cmd_rsock.setblocking(0) self.cmd_wsock.setblocking(0) self.poller = select.select self._polling = False self._lock = threading.RLock() self.poll_thread = threading.Thread(target=self.poll) self.poll_thread.daemon = True self.poll_thread.start()
def __init__(self): if not Pycos._instance: Pycos._instance = self self._notifier = _AsyncNotifier() self._locations = set() self._location = None self._name = '' self.__cur_task = None self._tasks = {} self._scheduled = set() self._suspended = set() self._timeouts = [] self._quit = False self._daemons = 0 self._channels = {} self._rtasks = {} self._rchannels = {} self._atexit = [] self._polling = False self._lock = threading.RLock() self._complete = threading.Event() self._complete.set() self._scheduler = threading.Thread(target=self._schedule) Pycos._schedulers[id(self._scheduler)] = self self._scheduler.daemon = True self._scheduler.start() if Pycos._instance == self: atexit.register(self.finish) logger.info('version %s with %s I/O notifier', __version__, self._notifier._poller_name)
def __getstate__(self): """Unlike a normal CookieJar, this class is pickleable.""" state = self.__dict__.copy() # remove the unpickleable RLock object state.pop('_cookies_lock') return state
def __setstate__(self, state): """Unlike a normal CookieJar, this class is pickleable.""" self.__dict__.update(state) if '_cookies_lock' not in self.__dict__: self._cookies_lock = threading.RLock()
def __init__(self, maxsize=10, dispose_func=None): self._maxsize = maxsize self.dispose_func = dispose_func self._container = self.ContainerCls() self.lock = RLock()
def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) self.threadControlLock = threading.RLock() self.process_thread = None # self.auto_start is deprecated and is only kept for API compatibility # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False
def __init__(self, identifier, execparams): loggerName = (execparams['NAME_BINDING'].replace('/', '.')).rsplit("_", 1)[0] Resource.__init__(self, identifier, execparams, loggerName=loggerName) self.threadControlLock = threading.RLock() self.process_thread = None # self.auto_start is deprecated and is only kept for API compatability # with 1.7.X and 1.8.0 components. This variable may be removed # in future releases self.auto_start = False
