threading :: _DummyThread :: Class _DummyThread
[hide private]
[frames] | no frames]

Class _DummyThread

source code

object --+        
         |        
  _Verbose --+    
             |    
        Thread --+
                 |
                _DummyThread

Instance Methods [hide private]
 
__init__(self)
This constructor should always be called with keyword arguments.
source code
 
_set_daemon(self) source code
 
join(self, timeout=None)
Wait until the thread terminates.
source code

Inherited from Thread: __repr__, getName, isAlive, isDaemon, is_alive, run, setDaemon, setName, start

Inherited from Thread (private): _reset_internal_locks, _set_ident

Inherited from _Verbose (private): _note

Inherited from object: __delattr__, __format__, __getattribute__, __hash__, __new__, __reduce__, __reduce_ex__, __setattr__, __sizeof__, __str__, __subclasshook__

Properties [hide private]

Inherited from Thread: daemon, ident, name

Inherited from Thread (private): _block

Inherited from object: __class__

Method Details [hide private]

__init__(self)
(Constructor)

source code 

This constructor should always be called with keyword arguments. Arguments are:

*group* should be None; reserved for future extension when a ThreadGroup class is implemented.

*target* is the callable object to be invoked by the run() method. Defaults to None, meaning nothing is called.

*name* is the thread name. By default, a unique name is constructed of the form "Thread-N" where N is a small decimal number.

*args* is the argument tuple for the target invocation. Defaults to ().

*kwargs* is a dictionary of keyword arguments for the target invocation. Defaults to {}.

If a subclass overrides the constructor, it must make sure to invoke the base class constructor (Thread.__init__()) before doing anything else to the thread.

Overrides: object.__init__
(inherited documentation)

_set_daemon(self)

source code 
Overrides: Thread._set_daemon

join(self, timeout=None)

source code 

Wait until the thread terminates.

This blocks the calling thread until the thread whose join() method is called terminates -- either normally or through an unhandled exception or until the optional timeout occurs.

When the timeout argument is present and not None, it should be a floating point number specifying a timeout for the operation in seconds (or fractions thereof). As join() always returns None, you must call isAlive() after join() to decide whether a timeout happened -- if the thread is still alive, the join() call timed out.

When the timeout argument is not present or None, the operation will block until the thread terminates.

A thread can be join()ed many times.

join() raises a RuntimeError if an attempt is made to join the current thread as that would cause a deadlock. It is also an error to join() a thread before it has been started and attempts to do so raises the same exception.

Overrides: Thread.join
(inherited documentation)