The :mod:`dummy_threading` module is provided for situations where
:mod:`threading` cannot be used because :mod:`thread` is missing.
+.. note::
+
+ In 3.x, names in camelCase have been renamed to their underscored
+ equivelents. Both names are availble in 2.6.
+
This module defines the following functions and objects:
.. function:: active_count()
+ activeCount()
Return the number of :class:`Thread` objects currently alive. The returned
count is equal to the length of the list returned by :func:`enumerate`.
.. function:: current_thread()
+ currentThread()
Return the current :class:`Thread` object, corresponding to the caller's thread
of control. If the caller's thread of control was not created through the
.. method:: Condition.notify_all()
+ Condition.notifyAll()
Wake up all threads waiting on this condition. This method acts like
:meth:`notify`, but wakes up all waiting threads instead of one. If the calling
The internal flag is initially false.
-.. method:: Event.isSet()
+.. method:: Event.is_set()
+ Event.isSet()
Return true if and only if the internal flag is true.
.. method:: Thread.get_name()
+ Thread.getName()
Return the thread's name.
-.. method:: Thread.set_same(name)
+.. method:: Thread.set_name(name)
+ Thread.setName(name)
Set the thread's name.
constructor.
-.. method:: Thread.get_ddent()
+.. method:: Thread.get_ident()
Return the 'thread identifier' of this thread or None if the thread has not
been started. This is a nonzero integer. See the :func:`thread.get_ident()`
.. method:: Thread.is_alive()
+ Thread.isAlive()
Return whether the thread is alive.
.. method:: Thread.is_daemon()
+ Thread.isDaemon()
Return the thread's daemon flag.
.. method:: Thread.set_daemon(daemonic)
+ Thread.setDaemon(daemonic)
Set the thread's daemon flag to the Boolean value *daemonic*. This must be
called before :meth:`start` is called, otherwise :exc:`RuntimeError` is raised.
raise
import warnings
+
+from functools import wraps
from time import time as _time, sleep as _sleep
from traceback import format_exc as _format_exc
from collections import deque
module='threading', message='sys.exc_clear')
+def _old_api(callable, old_name):
+ if not _sys.py3kwarning:
+ return callable
+ @wraps(callable)
+ def old(*args, **kwargs):
+ warnings.warnpy3k("In 3.x, {0} is renamed to {1}."
+ .format(old_name, callable.__name__),
+ stacklevel=3)
+ return callable(*args, **kwargs)
+ old.__name__ = old_name
+ return old
+
# Debug support (adapted from ihooks.py).
# All the major classes here derive from _Verbose. We force that to
# be a new-style class so that all the major classes here are new-style.
def notify_all(self):
self.notify(len(self.__waiters))
+ notifyAll = _old_api(notify_all, "notifyAll")
+
def Semaphore(*args, **kwargs):
return _Semaphore(*args, **kwargs)
def is_set(self):
return self.__flag
+ isSet = _old_api(is_set, "isSet")
+
def set(self):
self.__cond.acquire()
try:
assert self.__initialized, "Thread.__init__() not called"
return self.__name
+ getName = _old_api(get_name, "getName")
+
def set_name(self, name):
assert self.__initialized, "Thread.__init__() not called"
self.__name = str(name)
+ setName = _old_api(set_name, "setName")
+
def get_ident(self):
assert self.__initialized, "Thread.__init__() not called"
return self.__ident
assert self.__initialized, "Thread.__init__() not called"
return self.__started.is_set() and not self.__stopped
+ isAlive = _old_api(is_alive, "isAlive")
+
def is_daemon(self):
assert self.__initialized, "Thread.__init__() not called"
return self.__daemonic
+ isDaemon = _old_api(is_daemon, "isDaemon")
+
def set_daemon(self, daemonic):
if not self.__initialized:
raise RuntimeError("Thread.__init__() not called")
raise RuntimeError("cannot set daemon status of active thread");
self.__daemonic = daemonic
+ setDaemon = _old_api(set_daemon, "setDaemon")
+
# The timer class was contributed by Itamar Shtull-Trauring
def Timer(*args, **kwargs):
##print "current_thread(): no current thread for", _get_ident()
return _DummyThread()
+currentThread = _old_api(current_thread, "currentThread")
+
def active_count():
_active_limbo_lock.acquire()
count = len(_active) + len(_limbo)
_active_limbo_lock.release()
return count
+activeCount = _old_api(active_count, "activeCount")
+
def enumerate():
_active_limbo_lock.acquire()
active = _active.values() + _limbo.values()
projects / python / commitdiff