Lines Matching refs:self
113 def __init__(self):
114 self._block = _allocate_lock()
115 self._owner = None
116 self._count = 0
118 def __repr__(self):
119 owner = self._owner
125 "locked" if self._block.locked() else "unlocked",
126 self.__class__.__module__,
127 self.__class__.__qualname__,
129 self._count,
130 hex(id(self))
133 def _at_fork_reinit(self):
134 self._block._at_fork_reinit()
135 self._owner = None
136 self._count = 0
138 def acquire(self, blocking=True, timeout=-1):
165 if self._owner == me:
166 self._count += 1
168 rc = self._block.acquire(blocking, timeout)
170 self._owner = me
171 self._count = 1
176 def release(self):
192 if self._owner != get_ident():
194 self._count = count = self._count - 1
196 self._owner = None
197 self._block.release()
199 def __exit__(self, t, v, tb):
200 self.release()
204 def _acquire_restore(self, state):
205 self._block.acquire()
206 self._count, self._owner = state
208 def _release_save(self):
209 if self._count == 0:
211 count = self._count
212 self._count = 0
213 owner = self._owner
214 self._owner = None
215 self._block.release()
218 def _is_owned(self):
219 return self._owner == get_ident()
236 def __init__(self, lock=None):
239 self._lock = lock
241 self.acquire = lock.acquire
242 self.release = lock.release
247 self._release_save = lock._release_save
251 self._acquire_restore = lock._acquire_restore
255 self._is_owned = lock._is_owned
258 self._waiters = _deque()
260 def _at_fork_reinit(self):
261 self._lock._at_fork_reinit()
262 self._waiters.clear()
264 def __enter__(self):
265 return self._lock.__enter__()
267 def __exit__(self, *args):
268 return self._lock.__exit__(*args)
270 def __repr__(self):
271 return "<Condition(%s, %d)>" % (self._lock, len(self._waiters))
273 def _release_save(self):
274 self._lock.release() # No state to save
276 def _acquire_restore(self, x):
277 self._lock.acquire() # Ignore saved state
279 def _is_owned(self):
282 if self._lock.acquire(False):
283 self._lock.release()
288 def wait(self, timeout=None):
311 if not self._is_owned():
315 self._waiters.append(waiter)
316 saved_state = self._release_save()
329 self._acquire_restore(saved_state)
332 self._waiters.remove(waiter)
336 def wait_for(self, predicate, timeout=None):
355 self.wait(waittime)
359 def notify(self, n=1):
369 if not self._is_owned():
371 waiters = self._waiters
389 def notify_all(self):
396 self.notify(len(self._waiters))
398 def notifyAll(self):
407 self.notify_all()
422 def __init__(self, value=1):
425 self._cond = Condition(Lock())
426 self._value = value
428 def __repr__(self):
429 cls = self.__class__
430 return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
431 f" value={self._value}>")
433 def acquire(self, blocking=True, timeout=None):
461 with self._cond:
462 while self._value == 0:
472 self._cond.wait(timeout)
474 self._value -= 1
480 def release(self, n=1):
489 with self._cond:
490 self._value += n
492 self._cond.notify()
494 def __exit__(self, t, v, tb):
495 self.release()
515 def __init__(self, value=1):
516 Semaphore.__init__(self, value)
517 self._initial_value = value
519 def __repr__(self):
520 cls = self.__class__
521 return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
522 f" value={self._value}/{self._initial_value}>")
524 def release(self, n=1):
536 with self._cond:
537 if self._value + n > self._initial_value:
539 self._value += n
541 self._cond.notify()
555 def __init__(self):
556 self._cond = Condition(Lock())
557 self._flag = False
559 def __repr__(self):
560 cls = self.__class__
561 status = 'set' if self._flag else 'unset'
562 return f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}: {status}>"
564 def _at_fork_reinit(self):
566 self._cond._at_fork_reinit()
568 def is_set(self):
570 return self._flag
572 def isSet(self):
581 return self.is_set()
583 def set(self):
590 with self._cond:
591 self._flag = True
592 self._cond.notify_all()
594 def clear(self):
601 with self._cond:
602 self._flag = False
604 def wait(self, timeout=None):
619 with self._cond:
620 signaled = self._flag
622 signaled = self._cond.wait(timeout)
646 def __init__(self, parties, action=None, timeout=None):
655 self._cond = Condition(Lock())
656 self._action = action
657 self._timeout = timeout
658 self._parties = parties
659 self._state = 0 # 0 filling, 1 draining, -1 resetting, -2 broken
660 self._count = 0
662 def __repr__(self):
663 cls = self.__class__
664 if self.broken:
665 return f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}: broken>"
666 return (f"<{cls.__module__}.{cls.__qualname__} at {id(self):#x}:"
667 f" waiters={self.n_waiting}/{self.parties}>")
669 def wait(self, timeout=None):
679 timeout = self._timeout
680 with self._cond:
681 self._enter() # Block while the barrier drains.
682 index = self._count
683 self._count += 1
685 if index + 1 == self._parties:
687 self._release()
690 self._wait(timeout)
693 self._count -= 1
695 self._exit()
699 def _enter(self):
700 while self._state in (-1, 1):
702 self._cond.wait()
704 if self._state < 0:
706 assert self._state == 0
710 def _release(self):
712 if self._action:
713 self._action()
715 self._state = 1
716 self._cond.notify_all()
719 self._break()
724 def _wait(self, timeout):
725 if not self._cond.wait_for(lambda : self._state != 0, timeout):
727 self._break()
729 if self._state < 0:
731 assert self._state == 1
735 def _exit(self):
736 if self._count == 0:
737 if self._state in (-1, 1):
739 self._state = 0
740 self._cond.notify_all()
742 def reset(self):
749 with self._cond:
750 if self._count > 0:
751 if self._state == 0:
753 self._state = -1
754 elif self._state == -2:
757 self._state = -1
759 self._state = 0
760 self._cond.notify_all()
762 def abort(self):
769 with self._cond:
770 self._break()
772 def _break(self):
775 self._state = -2
776 self._cond.notify_all()
779 def parties(self):
781 return self._parties
784 def n_waiting(self):
788 if self._state == 0:
789 return self._count
793 def broken(self):
795 return self._state == -2
849 def __init__(self, group=None, target=None, name=None,
886 self._target = target
887 self._name = name
888 self._args = args
889 self._kwargs = kwargs
891 self._daemonic = daemon
893 self._daemonic = current_thread().daemon
894 self._ident = None
896 self._native_id = None
897 self._tstate_lock = None
898 self._started = Event()
899 self._is_stopped = False
900 self._initialized = True
901 # Copy of sys.stderr used by self._invoke_excepthook()
902 self._stderr = _sys.stderr
903 self._invoke_excepthook = _make_invoke_excepthook()
905 _dangling.add(self)
907 def _reset_internal_locks(self, is_alive):
910 self._started._at_fork_reinit()
915 if self._tstate_lock is not None:
916 self._tstate_lock._at_fork_reinit()
917 self._tstate_lock.acquire()
921 self._is_stopped = True
922 self._tstate_lock = None
924 def __repr__(self):
925 assert self._initialized, "Thread.__init__() was not called"
927 if self._started.is_set():
929 self.is_alive() # easy way to get ._is_stopped set when appropriate
930 if self._is_stopped:
932 if self._daemonic:
934 if self._ident is not None:
935 status += " %s" % self._ident
936 return "<%s(%s, %s)>" % (self.__class__.__name__, self._name, status)
938 def start(self):
948 if not self._initialized:
951 if self._started.is_set():
955 _limbo[self] = self
957 _start_new_thread(self._bootstrap, ())
960 del _limbo[self]
962 self._started.wait()
964 def run(self):
974 if self._target is not None:
975 self._target(*self._args, **self._kwargs)
979 del self._target, self._args, self._kwargs
981 def _bootstrap(self):
995 self._bootstrap_inner()
997 if self._daemonic and _sys is None:
1001 def _set_ident(self):
1002 self._ident = get_ident()
1005 def _set_native_id(self):
1006 self._native_id = get_native_id()
1008 def _set_tstate_lock(self):
1013 self._tstate_lock = _set_sentinel()
1014 self._tstate_lock.acquire()
1016 if not self.daemon:
1019 _shutdown_locks.add(self._tstate_lock)
1021 def _bootstrap_inner(self):
1023 self._set_ident()
1024 self._set_tstate_lock()
1026 self._set_native_id()
1027 self._started.set()
1029 _active[self._ident] = self
1030 del _limbo[self]
1038 self.run()
1040 self._invoke_excepthook(self)
1042 self._delete()
1044 def _stop(self):
1056 # "assert self._is_stopped" in ._wait_for_tstate_lock() always works
1061 lock = self._tstate_lock
1064 self._is_stopped = True
1065 self._tstate_lock = None
1066 if not self.daemon:
1071 def _delete(self):
1080 def join(self, timeout=None):
1104 if not self._initialized:
1106 if not self._started.is_set():
1108 if self is current_thread():
1112 self._wait_for_tstate_lock()
1116 self._wait_for_tstate_lock(timeout=max(timeout, 0))
1118 def _wait_for_tstate_lock(self, block=True, timeout=-1):
1123 # If the lock is acquired, the C code is done, and self._stop() is
1125 lock = self._tstate_lock
1128 assert self._is_stopped
1134 self._stop()
1142 self._stop()
1146 def name(self):
1153 assert self._initialized, "Thread.__init__() not called"
1154 return self._name
1157 def name(self, name):
1158 assert self._initialized, "Thread.__init__() not called"
1159 self._name = str(name)
1162 def ident(self):
1170 assert self._initialized, "Thread.__init__() not called"
1171 return self._ident
1175 def native_id(self):
1182 assert self._initialized, "Thread.__init__() not called"
1183 return self._native_id
1185 def is_alive(self):
1193 assert self._initialized, "Thread.__init__() not called"
1194 if self._is_stopped or not self._started.is_set():
1196 self._wait_for_tstate_lock(False)
1197 return not self._is_stopped
1200 def daemon(self):
1211 assert self._initialized, "Thread.__init__() not called"
1212 return self._daemonic
1215 def daemon(self, daemonic):
1216 if not self._initialized:
1218 if self._started.is_set():
1220 self._daemonic = daemonic
1222 def isDaemon(self):
1231 return self.daemon
1233 def setDaemon(self, daemonic):
1242 self.daemon = daemonic
1244 def getName(self):
1253 return self.name
1255 def setName(self, name):
1264 self.name = name
1379 def __init__(self, interval, function, args=None, kwargs=None):
1380 Thread.__init__(self)
1381 self.interval = interval
1382 self.function = function
1383 self.args = args if args is not None else []
1384 self.kwargs = kwargs if kwargs is not None else {}
1385 self.finished = Event()
1387 def cancel(self):
1389 self.finished.set()
1391 def run(self):
1392 self.finished.wait(self.interval)
1393 if not self.finished.is_set():
1394 self.function(*self.args, **self.kwargs)
1395 self.finished.set()
1402 def __init__(self):
1403 Thread.__init__(self, name="MainThread", daemon=False)
1404 self._set_tstate_lock()
1405 self._started.set()
1406 self._set_ident()
1408 self._set_native_id()
1410 _active[self._ident] = self
1423 def __init__(self):
1424 Thread.__init__(self, name=_newname("Dummy-%d"), daemon=True)
1426 self._started.set()
1427 self._set_ident()
1429 self._set_native_id()
1431 _active[self._ident] = self
1433 def _stop(self):
1436 def is_alive(self):
1437 assert not self._is_stopped and self._started.is_set()
1440 def join(self, timeout=None):