| 1 | """Thread module emulating a subset of Java's threading model."""
|
|---|
| 2 |
|
|---|
| 3 | import sys as _sys
|
|---|
| 4 |
|
|---|
| 5 | try:
|
|---|
| 6 | import thread
|
|---|
| 7 | except ImportError:
|
|---|
| 8 | del _sys.modules[__name__]
|
|---|
| 9 | raise
|
|---|
| 10 |
|
|---|
| 11 | from time import time as _time, sleep as _sleep
|
|---|
| 12 | from traceback import format_exc as _format_exc
|
|---|
| 13 | from collections import deque
|
|---|
| 14 |
|
|---|
| 15 | # Rename some stuff so "from threading import *" is safe
|
|---|
| 16 | __all__ = ['activeCount', 'Condition', 'currentThread', 'enumerate', 'Event',
|
|---|
| 17 | 'Lock', 'RLock', 'Semaphore', 'BoundedSemaphore', 'Thread',
|
|---|
| 18 | 'Timer', 'setprofile', 'settrace', 'local', 'stack_size']
|
|---|
| 19 |
|
|---|
| 20 | _start_new_thread = thread.start_new_thread
|
|---|
| 21 | _allocate_lock = thread.allocate_lock
|
|---|
| 22 | _get_ident = thread.get_ident
|
|---|
| 23 | ThreadError = thread.error
|
|---|
| 24 | del thread
|
|---|
| 25 |
|
|---|
| 26 |
|
|---|
| 27 | # Debug support (adapted from ihooks.py).
|
|---|
| 28 | # All the major classes here derive from _Verbose. We force that to
|
|---|
| 29 | # be a new-style class so that all the major classes here are new-style.
|
|---|
| 30 | # This helps debugging (type(instance) is more revealing for instances
|
|---|
| 31 | # of new-style classes).
|
|---|
| 32 |
|
|---|
| 33 | _VERBOSE = False
|
|---|
| 34 |
|
|---|
| 35 | if __debug__:
|
|---|
| 36 |
|
|---|
| 37 | class _Verbose(object):
|
|---|
| 38 |
|
|---|
| 39 | def __init__(self, verbose=None):
|
|---|
| 40 | if verbose is None:
|
|---|
| 41 | verbose = _VERBOSE
|
|---|
| 42 | self.__verbose = verbose
|
|---|
| 43 |
|
|---|
| 44 | def _note(self, format, *args):
|
|---|
| 45 | if self.__verbose:
|
|---|
| 46 | format = format % args
|
|---|
| 47 | format = "%s: %s\n" % (
|
|---|
| 48 | currentThread().getName(), format)
|
|---|
| 49 | _sys.stderr.write(format)
|
|---|
| 50 |
|
|---|
| 51 | else:
|
|---|
| 52 | # Disable this when using "python -O"
|
|---|
| 53 | class _Verbose(object):
|
|---|
| 54 | def __init__(self, verbose=None):
|
|---|
| 55 | pass
|
|---|
| 56 | def _note(self, *args):
|
|---|
| 57 | pass
|
|---|
| 58 |
|
|---|
| 59 | # Support for profile and trace hooks
|
|---|
| 60 |
|
|---|
| 61 | _profile_hook = None
|
|---|
| 62 | _trace_hook = None
|
|---|
| 63 |
|
|---|
| 64 | def setprofile(func):
|
|---|
| 65 | global _profile_hook
|
|---|
| 66 | _profile_hook = func
|
|---|
| 67 |
|
|---|
| 68 | def settrace(func):
|
|---|
| 69 | global _trace_hook
|
|---|
| 70 | _trace_hook = func
|
|---|
| 71 |
|
|---|
| 72 | # Synchronization classes
|
|---|
| 73 |
|
|---|
| 74 | Lock = _allocate_lock
|
|---|
| 75 |
|
|---|
| 76 | def RLock(*args, **kwargs):
|
|---|
| 77 | return _RLock(*args, **kwargs)
|
|---|
| 78 |
|
|---|
| 79 | class _RLock(_Verbose):
|
|---|
| 80 |
|
|---|
| 81 | def __init__(self, verbose=None):
|
|---|
| 82 | _Verbose.__init__(self, verbose)
|
|---|
| 83 | self.__block = _allocate_lock()
|
|---|
| 84 | self.__owner = None
|
|---|
| 85 | self.__count = 0
|
|---|
| 86 |
|
|---|
| 87 | def __repr__(self):
|
|---|
| 88 | return "<%s(%s, %d)>" % (
|
|---|
| 89 | self.__class__.__name__,
|
|---|
| 90 | self.__owner and self.__owner.getName(),
|
|---|
| 91 | self.__count)
|
|---|
| 92 |
|
|---|
| 93 | def acquire(self, blocking=1):
|
|---|
| 94 | me = currentThread()
|
|---|
| 95 | if self.__owner is me:
|
|---|
| 96 | self.__count = self.__count + 1
|
|---|
| 97 | if __debug__:
|
|---|
| 98 | self._note("%s.acquire(%s): recursive success", self, blocking)
|
|---|
| 99 | return 1
|
|---|
| 100 | rc = self.__block.acquire(blocking)
|
|---|
| 101 | if rc:
|
|---|
| 102 | self.__owner = me
|
|---|
| 103 | self.__count = 1
|
|---|
| 104 | if __debug__:
|
|---|
| 105 | self._note("%s.acquire(%s): initial success", self, blocking)
|
|---|
| 106 | else:
|
|---|
| 107 | if __debug__:
|
|---|
| 108 | self._note("%s.acquire(%s): failure", self, blocking)
|
|---|
| 109 | return rc
|
|---|
| 110 |
|
|---|
| 111 | __enter__ = acquire
|
|---|
| 112 |
|
|---|
| 113 | def release(self):
|
|---|
| 114 | me = currentThread()
|
|---|
| 115 | assert self.__owner is me, "release() of un-acquire()d lock"
|
|---|
| 116 | self.__count = count = self.__count - 1
|
|---|
| 117 | if not count:
|
|---|
| 118 | self.__owner = None
|
|---|
| 119 | self.__block.release()
|
|---|
| 120 | if __debug__:
|
|---|
| 121 | self._note("%s.release(): final release", self)
|
|---|
| 122 | else:
|
|---|
| 123 | if __debug__:
|
|---|
| 124 | self._note("%s.release(): non-final release", self)
|
|---|
| 125 |
|
|---|
| 126 | def __exit__(self, t, v, tb):
|
|---|
| 127 | self.release()
|
|---|
| 128 |
|
|---|
| 129 | # Internal methods used by condition variables
|
|---|
| 130 |
|
|---|
| 131 | def _acquire_restore(self, (count, owner)):
|
|---|
| 132 | self.__block.acquire()
|
|---|
| 133 | self.__count = count
|
|---|
| 134 | self.__owner = owner
|
|---|
| 135 | if __debug__:
|
|---|
| 136 | self._note("%s._acquire_restore()", self)
|
|---|
| 137 |
|
|---|
| 138 | def _release_save(self):
|
|---|
| 139 | if __debug__:
|
|---|
| 140 | self._note("%s._release_save()", self)
|
|---|
| 141 | count = self.__count
|
|---|
| 142 | self.__count = 0
|
|---|
| 143 | owner = self.__owner
|
|---|
| 144 | self.__owner = None
|
|---|
| 145 | self.__block.release()
|
|---|
| 146 | return (count, owner)
|
|---|
| 147 |
|
|---|
| 148 | def _is_owned(self):
|
|---|
| 149 | return self.__owner is currentThread()
|
|---|
| 150 |
|
|---|
| 151 |
|
|---|
| 152 | def Condition(*args, **kwargs):
|
|---|
| 153 | return _Condition(*args, **kwargs)
|
|---|
| 154 |
|
|---|
| 155 | class _Condition(_Verbose):
|
|---|
| 156 |
|
|---|
| 157 | def __init__(self, lock=None, verbose=None):
|
|---|
| 158 | _Verbose.__init__(self, verbose)
|
|---|
| 159 | if lock is None:
|
|---|
| 160 | lock = RLock()
|
|---|
| 161 | self.__lock = lock
|
|---|
| 162 | # Export the lock's acquire() and release() methods
|
|---|
| 163 | self.acquire = lock.acquire
|
|---|
| 164 | self.release = lock.release
|
|---|
| 165 | # If the lock defines _release_save() and/or _acquire_restore(),
|
|---|
| 166 | # these override the default implementations (which just call
|
|---|
| 167 | # release() and acquire() on the lock). Ditto for _is_owned().
|
|---|
| 168 | try:
|
|---|
| 169 | self._release_save = lock._release_save
|
|---|
| 170 | except AttributeError:
|
|---|
| 171 | pass
|
|---|
| 172 | try:
|
|---|
| 173 | self._acquire_restore = lock._acquire_restore
|
|---|
| 174 | except AttributeError:
|
|---|
| 175 | pass
|
|---|
| 176 | try:
|
|---|
| 177 | self._is_owned = lock._is_owned
|
|---|
| 178 | except AttributeError:
|
|---|
| 179 | pass
|
|---|
| 180 | self.__waiters = []
|
|---|
| 181 |
|
|---|
| 182 | def __enter__(self):
|
|---|
| 183 | return self.__lock.__enter__()
|
|---|
| 184 |
|
|---|
| 185 | def __exit__(self, *args):
|
|---|
| 186 | return self.__lock.__exit__(*args)
|
|---|
| 187 |
|
|---|
| 188 | def __repr__(self):
|
|---|
| 189 | return "<Condition(%s, %d)>" % (self.__lock, len(self.__waiters))
|
|---|
| 190 |
|
|---|
| 191 | def _release_save(self):
|
|---|
| 192 | self.__lock.release() # No state to save
|
|---|
| 193 |
|
|---|
| 194 | def _acquire_restore(self, x):
|
|---|
| 195 | self.__lock.acquire() # Ignore saved state
|
|---|
| 196 |
|
|---|
| 197 | def _is_owned(self):
|
|---|
| 198 | # Return True if lock is owned by currentThread.
|
|---|
| 199 | # This method is called only if __lock doesn't have _is_owned().
|
|---|
| 200 | if self.__lock.acquire(0):
|
|---|
| 201 | self.__lock.release()
|
|---|
| 202 | return False
|
|---|
| 203 | else:
|
|---|
| 204 | return True
|
|---|
| 205 |
|
|---|
| 206 | def wait(self, timeout=None):
|
|---|
| 207 | assert self._is_owned(), "wait() of un-acquire()d lock"
|
|---|
| 208 | waiter = _allocate_lock()
|
|---|
| 209 | waiter.acquire()
|
|---|
| 210 | self.__waiters.append(waiter)
|
|---|
| 211 | saved_state = self._release_save()
|
|---|
| 212 | try: # restore state no matter what (e.g., KeyboardInterrupt)
|
|---|
| 213 | if timeout is None:
|
|---|
| 214 | waiter.acquire()
|
|---|
| 215 | if __debug__:
|
|---|
| 216 | self._note("%s.wait(): got it", self)
|
|---|
| 217 | else:
|
|---|
| 218 | # Balancing act: We can't afford a pure busy loop, so we
|
|---|
| 219 | # have to sleep; but if we sleep the whole timeout time,
|
|---|
| 220 | # we'll be unresponsive. The scheme here sleeps very
|
|---|
| 221 | # little at first, longer as time goes on, but never longer
|
|---|
| 222 | # than 20 times per second (or the timeout time remaining).
|
|---|
| 223 | endtime = _time() + timeout
|
|---|
| 224 | delay = 0.0005 # 500 us -> initial delay of 1 ms
|
|---|
| 225 | while True:
|
|---|
| 226 | gotit = waiter.acquire(0)
|
|---|
| 227 | if gotit:
|
|---|
| 228 | break
|
|---|
| 229 | remaining = endtime - _time()
|
|---|
| 230 | if remaining <= 0:
|
|---|
| 231 | break
|
|---|
| 232 | delay = min(delay * 2, remaining, .05)
|
|---|
| 233 | _sleep(delay)
|
|---|
| 234 | if not gotit:
|
|---|
| 235 | if __debug__:
|
|---|
| 236 | self._note("%s.wait(%s): timed out", self, timeout)
|
|---|
| 237 | try:
|
|---|
| 238 | self.__waiters.remove(waiter)
|
|---|
| 239 | except ValueError:
|
|---|
| 240 | pass
|
|---|
| 241 | else:
|
|---|
| 242 | if __debug__:
|
|---|
| 243 | self._note("%s.wait(%s): got it", self, timeout)
|
|---|
| 244 | finally:
|
|---|
| 245 | self._acquire_restore(saved_state)
|
|---|
| 246 |
|
|---|
| 247 | def notify(self, n=1):
|
|---|
| 248 | assert self._is_owned(), "notify() of un-acquire()d lock"
|
|---|
| 249 | __waiters = self.__waiters
|
|---|
| 250 | waiters = __waiters[:n]
|
|---|
| 251 | if not waiters:
|
|---|
| 252 | if __debug__:
|
|---|
| 253 | self._note("%s.notify(): no waiters", self)
|
|---|
| 254 | return
|
|---|
| 255 | self._note("%s.notify(): notifying %d waiter%s", self, n,
|
|---|
| 256 | n!=1 and "s" or "")
|
|---|
| 257 | for waiter in waiters:
|
|---|
| 258 | waiter.release()
|
|---|
| 259 | try:
|
|---|
| 260 | __waiters.remove(waiter)
|
|---|
| 261 | except ValueError:
|
|---|
| 262 | pass
|
|---|
| 263 |
|
|---|
| 264 | def notifyAll(self):
|
|---|
| 265 | self.notify(len(self.__waiters))
|
|---|
| 266 |
|
|---|
| 267 |
|
|---|
| 268 | def Semaphore(*args, **kwargs):
|
|---|
| 269 | return _Semaphore(*args, **kwargs)
|
|---|
| 270 |
|
|---|
| 271 | class _Semaphore(_Verbose):
|
|---|
| 272 |
|
|---|
| 273 | # After Tim Peters' semaphore class, but not quite the same (no maximum)
|
|---|
| 274 |
|
|---|
| 275 | def __init__(self, value=1, verbose=None):
|
|---|
| 276 | assert value >= 0, "Semaphore initial value must be >= 0"
|
|---|
| 277 | _Verbose.__init__(self, verbose)
|
|---|
| 278 | self.__cond = Condition(Lock())
|
|---|
| 279 | self.__value = value
|
|---|
| 280 |
|
|---|
| 281 | def acquire(self, blocking=1):
|
|---|
| 282 | rc = False
|
|---|
| 283 | self.__cond.acquire()
|
|---|
| 284 | while self.__value == 0:
|
|---|
| 285 | if not blocking:
|
|---|
| 286 | break
|
|---|
| 287 | if __debug__:
|
|---|
| 288 | self._note("%s.acquire(%s): blocked waiting, value=%s",
|
|---|
| 289 | self, blocking, self.__value)
|
|---|
| 290 | self.__cond.wait()
|
|---|
| 291 | else:
|
|---|
| 292 | self.__value = self.__value - 1
|
|---|
| 293 | if __debug__:
|
|---|
| 294 | self._note("%s.acquire: success, value=%s",
|
|---|
| 295 | self, self.__value)
|
|---|
| 296 | rc = True
|
|---|
| 297 | self.__cond.release()
|
|---|
| 298 | return rc
|
|---|
| 299 |
|
|---|
| 300 | __enter__ = acquire
|
|---|
| 301 |
|
|---|
| 302 | def release(self):
|
|---|
| 303 | self.__cond.acquire()
|
|---|
| 304 | self.__value = self.__value + 1
|
|---|
| 305 | if __debug__:
|
|---|
| 306 | self._note("%s.release: success, value=%s",
|
|---|
| 307 | self, self.__value)
|
|---|
| 308 | self.__cond.notify()
|
|---|
| 309 | self.__cond.release()
|
|---|
| 310 |
|
|---|
| 311 | def __exit__(self, t, v, tb):
|
|---|
| 312 | self.release()
|
|---|
| 313 |
|
|---|
| 314 |
|
|---|
| 315 | def BoundedSemaphore(*args, **kwargs):
|
|---|
| 316 | return _BoundedSemaphore(*args, **kwargs)
|
|---|
| 317 |
|
|---|
| 318 | class _BoundedSemaphore(_Semaphore):
|
|---|
| 319 | """Semaphore that checks that # releases is <= # acquires"""
|
|---|
| 320 | def __init__(self, value=1, verbose=None):
|
|---|
| 321 | _Semaphore.__init__(self, value, verbose)
|
|---|
| 322 | self._initial_value = value
|
|---|
| 323 |
|
|---|
| 324 | def release(self):
|
|---|
| 325 | if self._Semaphore__value >= self._initial_value:
|
|---|
| 326 | raise ValueError, "Semaphore released too many times"
|
|---|
| 327 | return _Semaphore.release(self)
|
|---|
| 328 |
|
|---|
| 329 |
|
|---|
| 330 | def Event(*args, **kwargs):
|
|---|
| 331 | return _Event(*args, **kwargs)
|
|---|
| 332 |
|
|---|
| 333 | class _Event(_Verbose):
|
|---|
| 334 |
|
|---|
| 335 | # After Tim Peters' event class (without is_posted())
|
|---|
| 336 |
|
|---|
| 337 | def __init__(self, verbose=None):
|
|---|
| 338 | _Verbose.__init__(self, verbose)
|
|---|
| 339 | self.__cond = Condition(Lock())
|
|---|
| 340 | self.__flag = False
|
|---|
| 341 |
|
|---|
| 342 | def isSet(self):
|
|---|
| 343 | return self.__flag
|
|---|
| 344 |
|
|---|
| 345 | def set(self):
|
|---|
| 346 | self.__cond.acquire()
|
|---|
| 347 | try:
|
|---|
| 348 | self.__flag = True
|
|---|
| 349 | self.__cond.notifyAll()
|
|---|
| 350 | finally:
|
|---|
| 351 | self.__cond.release()
|
|---|
| 352 |
|
|---|
| 353 | def clear(self):
|
|---|
| 354 | self.__cond.acquire()
|
|---|
| 355 | try:
|
|---|
| 356 | self.__flag = False
|
|---|
| 357 | finally:
|
|---|
| 358 | self.__cond.release()
|
|---|
| 359 |
|
|---|
| 360 | def wait(self, timeout=None):
|
|---|
| 361 | self.__cond.acquire()
|
|---|
| 362 | try:
|
|---|
| 363 | if not self.__flag:
|
|---|
| 364 | self.__cond.wait(timeout)
|
|---|
| 365 | finally:
|
|---|
| 366 | self.__cond.release()
|
|---|
| 367 |
|
|---|
| 368 | # Helper to generate new thread names
|
|---|
| 369 | _counter = 0
|
|---|
| 370 | def _newname(template="Thread-%d"):
|
|---|
| 371 | global _counter
|
|---|
| 372 | _counter = _counter + 1
|
|---|
| 373 | return template % _counter
|
|---|
| 374 |
|
|---|
| 375 | # Active thread administration
|
|---|
| 376 | _active_limbo_lock = _allocate_lock()
|
|---|
| 377 | _active = {} # maps thread id to Thread object
|
|---|
| 378 | _limbo = {}
|
|---|
| 379 |
|
|---|
| 380 |
|
|---|
| 381 | # Main class for threads
|
|---|
| 382 |
|
|---|
| 383 | class Thread(_Verbose):
|
|---|
| 384 |
|
|---|
| 385 | __initialized = False
|
|---|
| 386 | # Need to store a reference to sys.exc_info for printing
|
|---|
| 387 | # out exceptions when a thread tries to use a global var. during interp.
|
|---|
| 388 | # shutdown and thus raises an exception about trying to perform some
|
|---|
| 389 | # operation on/with a NoneType
|
|---|
| 390 | __exc_info = _sys.exc_info
|
|---|
| 391 |
|
|---|
| 392 | def __init__(self, group=None, target=None, name=None,
|
|---|
| 393 | args=(), kwargs=None, verbose=None):
|
|---|
| 394 | assert group is None, "group argument must be None for now"
|
|---|
| 395 | _Verbose.__init__(self, verbose)
|
|---|
| 396 | if kwargs is None:
|
|---|
| 397 | kwargs = {}
|
|---|
| 398 | self.__target = target
|
|---|
| 399 | self.__name = str(name or _newname())
|
|---|
| 400 | self.__args = args
|
|---|
| 401 | self.__kwargs = kwargs
|
|---|
| 402 | self.__daemonic = self._set_daemon()
|
|---|
| 403 | self.__started = False
|
|---|
| 404 | self.__stopped = False
|
|---|
| 405 | self.__block = Condition(Lock())
|
|---|
| 406 | self.__initialized = True
|
|---|
| 407 | # sys.stderr is not stored in the class like
|
|---|
| 408 | # sys.exc_info since it can be changed between instances
|
|---|
| 409 | self.__stderr = _sys.stderr
|
|---|
| 410 |
|
|---|
| 411 | def _set_daemon(self):
|
|---|
| 412 | # Overridden in _MainThread and _DummyThread
|
|---|
| 413 | return currentThread().isDaemon()
|
|---|
| 414 |
|
|---|
| 415 | def __repr__(self):
|
|---|
| 416 | assert self.__initialized, "Thread.__init__() was not called"
|
|---|
| 417 | status = "initial"
|
|---|
| 418 | if self.__started:
|
|---|
| 419 | status = "started"
|
|---|
| 420 | if self.__stopped:
|
|---|
| 421 | status = "stopped"
|
|---|
| 422 | if self.__daemonic:
|
|---|
| 423 | status = status + " daemon"
|
|---|
| 424 | return "<%s(%s, %s)>" % (self.__class__.__name__, self.__name, status)
|
|---|
| 425 |
|
|---|
| 426 | def start(self):
|
|---|
| 427 | assert self.__initialized, "Thread.__init__() not called"
|
|---|
| 428 | assert not self.__started, "thread already started"
|
|---|
| 429 | if __debug__:
|
|---|
| 430 | self._note("%s.start(): starting thread", self)
|
|---|
| 431 | _active_limbo_lock.acquire()
|
|---|
| 432 | _limbo[self] = self
|
|---|
| 433 | _active_limbo_lock.release()
|
|---|
| 434 | _start_new_thread(self.__bootstrap, ())
|
|---|
| 435 | self.__started = True
|
|---|
| 436 | _sleep(0.000001) # 1 usec, to let the thread run (Solaris hack)
|
|---|
| 437 |
|
|---|
| 438 | def run(self):
|
|---|
| 439 | if self.__target:
|
|---|
| 440 | self.__target(*self.__args, **self.__kwargs)
|
|---|
| 441 |
|
|---|
| 442 | def __bootstrap(self):
|
|---|
| 443 | try:
|
|---|
| 444 | self.__started = True
|
|---|
| 445 | _active_limbo_lock.acquire()
|
|---|
| 446 | _active[_get_ident()] = self
|
|---|
| 447 | del _limbo[self]
|
|---|
| 448 | _active_limbo_lock.release()
|
|---|
| 449 | if __debug__:
|
|---|
| 450 | self._note("%s.__bootstrap(): thread started", self)
|
|---|
| 451 |
|
|---|
| 452 | if _trace_hook:
|
|---|
| 453 | self._note("%s.__bootstrap(): registering trace hook", self)
|
|---|
| 454 | _sys.settrace(_trace_hook)
|
|---|
| 455 | if _profile_hook:
|
|---|
| 456 | self._note("%s.__bootstrap(): registering profile hook", self)
|
|---|
| 457 | _sys.setprofile(_profile_hook)
|
|---|
| 458 |
|
|---|
| 459 | try:
|
|---|
| 460 | self.run()
|
|---|
| 461 | except SystemExit:
|
|---|
| 462 | if __debug__:
|
|---|
| 463 | self._note("%s.__bootstrap(): raised SystemExit", self)
|
|---|
| 464 | except:
|
|---|
| 465 | if __debug__:
|
|---|
| 466 | self._note("%s.__bootstrap(): unhandled exception", self)
|
|---|
| 467 | # If sys.stderr is no more (most likely from interpreter
|
|---|
| 468 | # shutdown) use self.__stderr. Otherwise still use sys (as in
|
|---|
| 469 | # _sys) in case sys.stderr was redefined since the creation of
|
|---|
| 470 | # self.
|
|---|
| 471 | if _sys:
|
|---|
| 472 | _sys.stderr.write("Exception in thread %s:\n%s\n" %
|
|---|
| 473 | (self.getName(), _format_exc()))
|
|---|
| 474 | else:
|
|---|
| 475 | # Do the best job possible w/o a huge amt. of code to
|
|---|
| 476 | # approximate a traceback (code ideas from
|
|---|
| 477 | # Lib/traceback.py)
|
|---|
| 478 | exc_type, exc_value, exc_tb = self.__exc_info()
|
|---|
| 479 | try:
|
|---|
| 480 | print>>self.__stderr, (
|
|---|
| 481 | "Exception in thread " + self.getName() +
|
|---|
| 482 | " (most likely raised during interpreter shutdown):")
|
|---|
| 483 | print>>self.__stderr, (
|
|---|
| 484 | "Traceback (most recent call last):")
|
|---|
| 485 | while exc_tb:
|
|---|
| 486 | print>>self.__stderr, (
|
|---|
| 487 | ' File "%s", line %s, in %s' %
|
|---|
| 488 | (exc_tb.tb_frame.f_code.co_filename,
|
|---|
| 489 | exc_tb.tb_lineno,
|
|---|
| 490 | exc_tb.tb_frame.f_code.co_name))
|
|---|
| 491 | exc_tb = exc_tb.tb_next
|
|---|
| 492 | print>>self.__stderr, ("%s: %s" % (exc_type, exc_value))
|
|---|
| 493 | # Make sure that exc_tb gets deleted since it is a memory
|
|---|
| 494 | # hog; deleting everything else is just for thoroughness
|
|---|
| 495 | finally:
|
|---|
| 496 | del exc_type, exc_value, exc_tb
|
|---|
| 497 | else:
|
|---|
| 498 | if __debug__:
|
|---|
| 499 | self._note("%s.__bootstrap(): normal return", self)
|
|---|
| 500 | finally:
|
|---|
| 501 | self.__stop()
|
|---|
| 502 | try:
|
|---|
| 503 | self.__delete()
|
|---|
| 504 | except:
|
|---|
| 505 | pass
|
|---|
| 506 |
|
|---|
| 507 | def __stop(self):
|
|---|
| 508 | self.__block.acquire()
|
|---|
| 509 | self.__stopped = True
|
|---|
| 510 | self.__block.notifyAll()
|
|---|
| 511 | self.__block.release()
|
|---|
| 512 |
|
|---|
| 513 | def __delete(self):
|
|---|
| 514 | "Remove current thread from the dict of currently running threads."
|
|---|
| 515 |
|
|---|
| 516 | # Notes about running with dummy_thread:
|
|---|
| 517 | #
|
|---|
| 518 | # Must take care to not raise an exception if dummy_thread is being
|
|---|
| 519 | # used (and thus this module is being used as an instance of
|
|---|
| 520 | # dummy_threading). dummy_thread.get_ident() always returns -1 since
|
|---|
| 521 | # there is only one thread if dummy_thread is being used. Thus
|
|---|
| 522 | # len(_active) is always <= 1 here, and any Thread instance created
|
|---|
| 523 | # overwrites the (if any) thread currently registered in _active.
|
|---|
| 524 | #
|
|---|
| 525 | # An instance of _MainThread is always created by 'threading'. This
|
|---|
| 526 | # gets overwritten the instant an instance of Thread is created; both
|
|---|
| 527 | # threads return -1 from dummy_thread.get_ident() and thus have the
|
|---|
| 528 | # same key in the dict. So when the _MainThread instance created by
|
|---|
| 529 | # 'threading' tries to clean itself up when atexit calls this method
|
|---|
| 530 | # it gets a KeyError if another Thread instance was created.
|
|---|
| 531 | #
|
|---|
| 532 | # This all means that KeyError from trying to delete something from
|
|---|
| 533 | # _active if dummy_threading is being used is a red herring. But
|
|---|
| 534 | # since it isn't if dummy_threading is *not* being used then don't
|
|---|
| 535 | # hide the exception.
|
|---|
| 536 |
|
|---|
| 537 | _active_limbo_lock.acquire()
|
|---|
| 538 | try:
|
|---|
| 539 | try:
|
|---|
| 540 | del _active[_get_ident()]
|
|---|
| 541 | except KeyError:
|
|---|
| 542 | if 'dummy_threading' not in _sys.modules:
|
|---|
| 543 | raise
|
|---|
| 544 | finally:
|
|---|
| 545 | _active_limbo_lock.release()
|
|---|
| 546 |
|
|---|
| 547 | def join(self, timeout=None):
|
|---|
| 548 | assert self.__initialized, "Thread.__init__() not called"
|
|---|
| 549 | assert self.__started, "cannot join thread before it is started"
|
|---|
| 550 | assert self is not currentThread(), "cannot join current thread"
|
|---|
| 551 | if __debug__:
|
|---|
| 552 | if not self.__stopped:
|
|---|
| 553 | self._note("%s.join(): waiting until thread stops", self)
|
|---|
| 554 | self.__block.acquire()
|
|---|
| 555 | try:
|
|---|
| 556 | if timeout is None:
|
|---|
| 557 | while not self.__stopped:
|
|---|
| 558 | self.__block.wait()
|
|---|
| 559 | if __debug__:
|
|---|
| 560 | self._note("%s.join(): thread stopped", self)
|
|---|
| 561 | else:
|
|---|
| 562 | deadline = _time() + timeout
|
|---|
| 563 | while not self.__stopped:
|
|---|
| 564 | delay = deadline - _time()
|
|---|
| 565 | if delay <= 0:
|
|---|
| 566 | if __debug__:
|
|---|
| 567 | self._note("%s.join(): timed out", self)
|
|---|
| 568 | break
|
|---|
| 569 | self.__block.wait(delay)
|
|---|
| 570 | else:
|
|---|
| 571 | if __debug__:
|
|---|
| 572 | self._note("%s.join(): thread stopped", self)
|
|---|
| 573 | finally:
|
|---|
| 574 | self.__block.release()
|
|---|
| 575 |
|
|---|
| 576 | def getName(self):
|
|---|
| 577 | assert self.__initialized, "Thread.__init__() not called"
|
|---|
| 578 | return self.__name
|
|---|
| 579 |
|
|---|
| 580 | def setName(self, name):
|
|---|
| 581 | assert self.__initialized, "Thread.__init__() not called"
|
|---|
| 582 | self.__name = str(name)
|
|---|
| 583 |
|
|---|
| 584 | def isAlive(self):
|
|---|
| 585 | assert self.__initialized, "Thread.__init__() not called"
|
|---|
| 586 | return self.__started and not self.__stopped
|
|---|
| 587 |
|
|---|
| 588 | def isDaemon(self):
|
|---|
| 589 | assert self.__initialized, "Thread.__init__() not called"
|
|---|
| 590 | return self.__daemonic
|
|---|
| 591 |
|
|---|
| 592 | def setDaemon(self, daemonic):
|
|---|
| 593 | assert self.__initialized, "Thread.__init__() not called"
|
|---|
| 594 | assert not self.__started, "cannot set daemon status of active thread"
|
|---|
| 595 | self.__daemonic = daemonic
|
|---|
| 596 |
|
|---|
| 597 | # The timer class was contributed by Itamar Shtull-Trauring
|
|---|
| 598 |
|
|---|
| 599 | def Timer(*args, **kwargs):
|
|---|
| 600 | return _Timer(*args, **kwargs)
|
|---|
| 601 |
|
|---|
| 602 | class _Timer(Thread):
|
|---|
| 603 | """Call a function after a specified number of seconds:
|
|---|
| 604 |
|
|---|
| 605 | t = Timer(30.0, f, args=[], kwargs={})
|
|---|
| 606 | t.start()
|
|---|
| 607 | t.cancel() # stop the timer's action if it's still waiting
|
|---|
| 608 | """
|
|---|
| 609 |
|
|---|
| 610 | def __init__(self, interval, function, args=[], kwargs={}):
|
|---|
| 611 | Thread.__init__(self)
|
|---|
| 612 | self.interval = interval
|
|---|
| 613 | self.function = function
|
|---|
| 614 | self.args = args
|
|---|
| 615 | self.kwargs = kwargs
|
|---|
| 616 | self.finished = Event()
|
|---|
| 617 |
|
|---|
| 618 | def cancel(self):
|
|---|
| 619 | """Stop the timer if it hasn't finished yet"""
|
|---|
| 620 | self.finished.set()
|
|---|
| 621 |
|
|---|
| 622 | def run(self):
|
|---|
| 623 | self.finished.wait(self.interval)
|
|---|
| 624 | if not self.finished.isSet():
|
|---|
| 625 | self.function(*self.args, **self.kwargs)
|
|---|
| 626 | self.finished.set()
|
|---|
| 627 |
|
|---|
| 628 | # Special thread class to represent the main thread
|
|---|
| 629 | # This is garbage collected through an exit handler
|
|---|
| 630 |
|
|---|
| 631 | class _MainThread(Thread):
|
|---|
| 632 |
|
|---|
| 633 | def __init__(self):
|
|---|
| 634 | Thread.__init__(self, name="MainThread")
|
|---|
| 635 | self._Thread__started = True
|
|---|
| 636 | _active_limbo_lock.acquire()
|
|---|
| 637 | _active[_get_ident()] = self
|
|---|
| 638 | _active_limbo_lock.release()
|
|---|
| 639 | import atexit
|
|---|
| 640 | atexit.register(self.__exitfunc)
|
|---|
| 641 |
|
|---|
| 642 | def _set_daemon(self):
|
|---|
| 643 | return False
|
|---|
| 644 |
|
|---|
| 645 | def __exitfunc(self):
|
|---|
| 646 | self._Thread__stop()
|
|---|
| 647 | t = _pickSomeNonDaemonThread()
|
|---|
| 648 | if t:
|
|---|
| 649 | if __debug__:
|
|---|
| 650 | self._note("%s: waiting for other threads", self)
|
|---|
| 651 | while t:
|
|---|
| 652 | t.join()
|
|---|
| 653 | t = _pickSomeNonDaemonThread()
|
|---|
| 654 | if __debug__:
|
|---|
| 655 | self._note("%s: exiting", self)
|
|---|
| 656 | self._Thread__delete()
|
|---|
| 657 |
|
|---|
| 658 | def _pickSomeNonDaemonThread():
|
|---|
| 659 | for t in enumerate():
|
|---|
| 660 | if not t.isDaemon() and t.isAlive():
|
|---|
| 661 | return t
|
|---|
| 662 | return None
|
|---|
| 663 |
|
|---|
| 664 |
|
|---|
| 665 | # Dummy thread class to represent threads not started here.
|
|---|
| 666 | # These aren't garbage collected when they die, nor can they be waited for.
|
|---|
| 667 | # If they invoke anything in threading.py that calls currentThread(), they
|
|---|
| 668 | # leave an entry in the _active dict forever after.
|
|---|
| 669 | # Their purpose is to return *something* from currentThread().
|
|---|
| 670 | # They are marked as daemon threads so we won't wait for them
|
|---|
| 671 | # when we exit (conform previous semantics).
|
|---|
| 672 |
|
|---|
| 673 | class _DummyThread(Thread):
|
|---|
| 674 |
|
|---|
| 675 | def __init__(self):
|
|---|
| 676 | Thread.__init__(self, name=_newname("Dummy-%d"))
|
|---|
| 677 |
|
|---|
| 678 | # Thread.__block consumes an OS-level locking primitive, which
|
|---|
| 679 | # can never be used by a _DummyThread. Since a _DummyThread
|
|---|
| 680 | # instance is immortal, that's bad, so release this resource.
|
|---|
| 681 | del self._Thread__block
|
|---|
| 682 |
|
|---|
| 683 | self._Thread__started = True
|
|---|
| 684 | _active_limbo_lock.acquire()
|
|---|
| 685 | _active[_get_ident()] = self
|
|---|
| 686 | _active_limbo_lock.release()
|
|---|
| 687 |
|
|---|
| 688 | def _set_daemon(self):
|
|---|
| 689 | return True
|
|---|
| 690 |
|
|---|
| 691 | def join(self, timeout=None):
|
|---|
| 692 | assert False, "cannot join a dummy thread"
|
|---|
| 693 |
|
|---|
| 694 |
|
|---|
| 695 | # Global API functions
|
|---|
| 696 |
|
|---|
| 697 | def currentThread():
|
|---|
| 698 | try:
|
|---|
| 699 | return _active[_get_ident()]
|
|---|
| 700 | except KeyError:
|
|---|
| 701 | ##print "currentThread(): no current thread for", _get_ident()
|
|---|
| 702 | return _DummyThread()
|
|---|
| 703 |
|
|---|
| 704 | def activeCount():
|
|---|
| 705 | _active_limbo_lock.acquire()
|
|---|
| 706 | count = len(_active) + len(_limbo)
|
|---|
| 707 | _active_limbo_lock.release()
|
|---|
| 708 | return count
|
|---|
| 709 |
|
|---|
| 710 | def enumerate():
|
|---|
| 711 | _active_limbo_lock.acquire()
|
|---|
| 712 | active = _active.values() + _limbo.values()
|
|---|
| 713 | _active_limbo_lock.release()
|
|---|
| 714 | return active
|
|---|
| 715 |
|
|---|
| 716 | from thread import stack_size
|
|---|
| 717 |
|
|---|
| 718 | # Create the main thread object
|
|---|
| 719 |
|
|---|
| 720 | _MainThread()
|
|---|
| 721 |
|
|---|
| 722 | # get thread-local implementation, either from the thread
|
|---|
| 723 | # module, or from the python fallback
|
|---|
| 724 |
|
|---|
| 725 | try:
|
|---|
| 726 | from thread import _local as local
|
|---|
| 727 | except ImportError:
|
|---|
| 728 | from _threading_local import local
|
|---|
| 729 |
|
|---|
| 730 |
|
|---|
| 731 | # Self-test code
|
|---|
| 732 |
|
|---|
| 733 | def _test():
|
|---|
| 734 |
|
|---|
| 735 | class BoundedQueue(_Verbose):
|
|---|
| 736 |
|
|---|
| 737 | def __init__(self, limit):
|
|---|
| 738 | _Verbose.__init__(self)
|
|---|
| 739 | self.mon = RLock()
|
|---|
| 740 | self.rc = Condition(self.mon)
|
|---|
| 741 | self.wc = Condition(self.mon)
|
|---|
| 742 | self.limit = limit
|
|---|
| 743 | self.queue = deque()
|
|---|
| 744 |
|
|---|
| 745 | def put(self, item):
|
|---|
| 746 | self.mon.acquire()
|
|---|
| 747 | while len(self.queue) >= self.limit:
|
|---|
| 748 | self._note("put(%s): queue full", item)
|
|---|
| 749 | self.wc.wait()
|
|---|
| 750 | self.queue.append(item)
|
|---|
| 751 | self._note("put(%s): appended, length now %d",
|
|---|
| 752 | item, len(self.queue))
|
|---|
| 753 | self.rc.notify()
|
|---|
| 754 | self.mon.release()
|
|---|
| 755 |
|
|---|
| 756 | def get(self):
|
|---|
| 757 | self.mon.acquire()
|
|---|
| 758 | while not self.queue:
|
|---|
| 759 | self._note("get(): queue empty")
|
|---|
| 760 | self.rc.wait()
|
|---|
| 761 | item = self.queue.popleft()
|
|---|
| 762 | self._note("get(): got %s, %d left", item, len(self.queue))
|
|---|
| 763 | self.wc.notify()
|
|---|
| 764 | self.mon.release()
|
|---|
| 765 | return item
|
|---|
| 766 |
|
|---|
| 767 | class ProducerThread(Thread):
|
|---|
| 768 |
|
|---|
| 769 | def __init__(self, queue, quota):
|
|---|
| 770 | Thread.__init__(self, name="Producer")
|
|---|
| 771 | self.queue = queue
|
|---|
| 772 | self.quota = quota
|
|---|
| 773 |
|
|---|
| 774 | def run(self):
|
|---|
| 775 | from random import random
|
|---|
| 776 | counter = 0
|
|---|
| 777 | while counter < self.quota:
|
|---|
| 778 | counter = counter + 1
|
|---|
| 779 | self.queue.put("%s.%d" % (self.getName(), counter))
|
|---|
| 780 | _sleep(random() * 0.00001)
|
|---|
| 781 |
|
|---|
| 782 |
|
|---|
| 783 | class ConsumerThread(Thread):
|
|---|
| 784 |
|
|---|
| 785 | def __init__(self, queue, count):
|
|---|
| 786 | Thread.__init__(self, name="Consumer")
|
|---|
| 787 | self.queue = queue
|
|---|
| 788 | self.count = count
|
|---|
| 789 |
|
|---|
| 790 | def run(self):
|
|---|
| 791 | while self.count > 0:
|
|---|
| 792 | item = self.queue.get()
|
|---|
| 793 | print item
|
|---|
| 794 | self.count = self.count - 1
|
|---|
| 795 |
|
|---|
| 796 | NP = 3
|
|---|
| 797 | QL = 4
|
|---|
| 798 | NI = 5
|
|---|
| 799 |
|
|---|
| 800 | Q = BoundedQueue(QL)
|
|---|
| 801 | P = []
|
|---|
| 802 | for i in range(NP):
|
|---|
| 803 | t = ProducerThread(Q, NI)
|
|---|
| 804 | t.setName("Producer-%d" % (i+1))
|
|---|
| 805 | P.append(t)
|
|---|
| 806 | C = ConsumerThread(Q, NI*NP)
|
|---|
| 807 | for t in P:
|
|---|
| 808 | t.start()
|
|---|
| 809 | _sleep(0.000001)
|
|---|
| 810 | C.start()
|
|---|
| 811 | for t in P:
|
|---|
| 812 | t.join()
|
|---|
| 813 | C.join()
|
|---|
| 814 |
|
|---|
| 815 | if __name__ == '__main__':
|
|---|
| 816 | _test()
|
|---|
