174 lines
13 KiB
HTML
174 lines
13 KiB
HTML
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
|
|
<html><head><title>Python: class StoppableThread</title>
|
|
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
|
|
</head><body bgcolor="#f0f0f8">
|
|
<p>
|
|
<table width="100%" cellspacing=0 cellpadding=2 border=0 summary="section">
|
|
<tr bgcolor="#ffc8d8">
|
|
<td colspan=3 valign=bottom> <br>
|
|
<font color="#000000" face="helvetica, arial"><strong>func_timeout.StoppableThread</strong> = <a name="func_timeout.StoppableThread">class StoppableThread</a>(<a href="threading.html#Thread">threading.Thread</a>)</font></td></tr>
|
|
|
|
<tr bgcolor="#ffc8d8"><td rowspan=2><tt> </tt></td>
|
|
<td colspan=2><tt>func_timeout.StoppableThread(group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None)<br>
|
|
<br>
|
|
StoppableThread - A thread that can be stopped by forcing an exception in the execution context.<br>
|
|
<br>
|
|
This works both to interrupt code that is in C or in python code, at either the next call to a python function,<br>
|
|
or the next line in python code.<br>
|
|
<br>
|
|
It is recommended that if you call stop ( @see StoppableThread.stop ) that you use an exception that inherits BaseException, to ensure it likely isn't caught.<br>
|
|
<br>
|
|
Also, beware unmarked exception handlers in your code. Code like this:<br>
|
|
<br>
|
|
while True:<br>
|
|
try:<br>
|
|
doSomething()<br>
|
|
except:<br>
|
|
continue<br>
|
|
<br>
|
|
will never be able to abort, because the exception you raise is immediately caught.<br>
|
|
<br>
|
|
The exception is raised over and over, with a specifed delay (default 2.0 seconds)<br> </tt></td></tr>
|
|
<tr><td> </td>
|
|
<td width="100%"><dl><dt>Method resolution order:</dt>
|
|
<dd><a href="func_timeout.StoppableThread.html#StoppableThread">StoppableThread</a></dd>
|
|
<dd><a href="threading.html#Thread">threading.Thread</a></dd>
|
|
<dd><a href="builtins.html#object">builtins.object</a></dd>
|
|
</dl>
|
|
<hr>
|
|
Methods defined here:<br>
|
|
<dl><dt><a name="StoppableThread-stop"><strong>stop</strong></a>(self, exception, raiseEvery=2.0)</dt><dd><tt>Stops the thread by raising a given exception.<br>
|
|
<br>
|
|
@param exception <Exception type> - Exception to throw. Likely, you want to use something<br>
|
|
<br>
|
|
that inherits from BaseException (so except Exception as e: continue; isn't a problem)<br>
|
|
<br>
|
|
This should be a class/type, NOT an instance, i.e. MyExceptionType not MyExceptionType()<br>
|
|
<br>
|
|
<br>
|
|
@param raiseEvery <float> Default 2.0 - We will keep raising this exception every #raiseEvery seconds,<br>
|
|
<br>
|
|
until the thread terminates.<br>
|
|
<br>
|
|
If your code traps a specific exception type, this will allow you #raiseEvery seconds to cleanup before exit.<br>
|
|
<br>
|
|
If you're calling third-party code you can't control, which catches BaseException, set this to a low number<br>
|
|
<br>
|
|
to break out of their exception handler.<br>
|
|
<br>
|
|
<br>
|
|
@return <None></tt></dd></dl>
|
|
|
|
<hr>
|
|
Methods inherited from <a href="threading.html#Thread">threading.Thread</a>:<br>
|
|
<dl><dt><a name="StoppableThread-__init__"><strong>__init__</strong></a>(self, group=None, target=None, name=None, args=(), kwargs=None, *, daemon=None)</dt><dd><tt>This constructor should always be called with keyword arguments. Arguments are:<br>
|
|
<br>
|
|
*group* should be None; reserved for future extension when a ThreadGroup<br>
|
|
class is implemented.<br>
|
|
<br>
|
|
*target* is the callable object to be invoked by the <a href="#func_timeout.StoppableThread-run">run</a>()<br>
|
|
method. Defaults to None, meaning nothing is called.<br>
|
|
<br>
|
|
*name* is the thread name. By default, a unique name is constructed of<br>
|
|
the form "Thread-N" where N is a small decimal number.<br>
|
|
<br>
|
|
*args* is the argument tuple for the target invocation. Defaults to ().<br>
|
|
<br>
|
|
*kwargs* is a dictionary of keyword arguments for the target<br>
|
|
invocation. Defaults to {}.<br>
|
|
<br>
|
|
If a subclass overrides the constructor, it must make sure to invoke<br>
|
|
the base class constructor (Thread.<a href="#func_timeout.StoppableThread-__init__">__init__</a>()) before doing anything<br>
|
|
else to the thread.</tt></dd></dl>
|
|
|
|
<dl><dt><a name="StoppableThread-__repr__"><strong>__repr__</strong></a>(self)</dt><dd><tt>Return repr(self).</tt></dd></dl>
|
|
|
|
<dl><dt><a name="StoppableThread-getName"><strong>getName</strong></a>(self)</dt></dl>
|
|
|
|
<dl><dt><a name="StoppableThread-isAlive"><strong>isAlive</strong></a>(self)</dt><dd><tt>Return whether the thread is alive.<br>
|
|
<br>
|
|
This method is deprecated, use <a href="#func_timeout.StoppableThread-is_alive">is_alive</a>() instead.</tt></dd></dl>
|
|
|
|
<dl><dt><a name="StoppableThread-isDaemon"><strong>isDaemon</strong></a>(self)</dt></dl>
|
|
|
|
<dl><dt><a name="StoppableThread-is_alive"><strong>is_alive</strong></a>(self)</dt><dd><tt>Return whether the thread is alive.<br>
|
|
<br>
|
|
This method returns True just before the <a href="#func_timeout.StoppableThread-run">run</a>() method starts until just<br>
|
|
after the <a href="#func_timeout.StoppableThread-run">run</a>() method terminates. The module function enumerate()<br>
|
|
returns a list of all alive threads.</tt></dd></dl>
|
|
|
|
<dl><dt><a name="StoppableThread-join"><strong>join</strong></a>(self, timeout=None)</dt><dd><tt>Wait until the thread terminates.<br>
|
|
<br>
|
|
This blocks the calling thread until the thread whose <a href="#func_timeout.StoppableThread-join">join</a>() method is<br>
|
|
called terminates -- either normally or through an unhandled exception<br>
|
|
or until the optional timeout occurs.<br>
|
|
<br>
|
|
When the timeout argument is present and not None, it should be a<br>
|
|
floating point number specifying a timeout for the operation in seconds<br>
|
|
(or fractions thereof). As <a href="#func_timeout.StoppableThread-join">join</a>() always returns None, you must call<br>
|
|
<a href="#func_timeout.StoppableThread-is_alive">is_alive</a>() after <a href="#func_timeout.StoppableThread-join">join</a>() to decide whether a timeout happened -- if the<br>
|
|
thread is still alive, the <a href="#func_timeout.StoppableThread-join">join</a>() call timed out.<br>
|
|
<br>
|
|
When the timeout argument is not present or None, the operation will<br>
|
|
block until the thread terminates.<br>
|
|
<br>
|
|
A thread can be <a href="#func_timeout.StoppableThread-join">join</a>()ed many times.<br>
|
|
<br>
|
|
<a href="#func_timeout.StoppableThread-join">join</a>() raises a RuntimeError if an attempt is made to join the current<br>
|
|
thread as that would cause a deadlock. It is also an error to <a href="#func_timeout.StoppableThread-join">join</a>() a<br>
|
|
thread before it has been started and attempts to do so raises the same<br>
|
|
exception.</tt></dd></dl>
|
|
|
|
<dl><dt><a name="StoppableThread-run"><strong>run</strong></a>(self)</dt><dd><tt>Method representing the thread's activity.<br>
|
|
<br>
|
|
You may override this method in a subclass. The standard <a href="#func_timeout.StoppableThread-run">run</a>() method<br>
|
|
invokes the callable object passed to the object's constructor as the<br>
|
|
target argument, if any, with sequential and keyword arguments taken<br>
|
|
from the args and kwargs arguments, respectively.</tt></dd></dl>
|
|
|
|
<dl><dt><a name="StoppableThread-setDaemon"><strong>setDaemon</strong></a>(self, daemonic)</dt></dl>
|
|
|
|
<dl><dt><a name="StoppableThread-setName"><strong>setName</strong></a>(self, name)</dt></dl>
|
|
|
|
<dl><dt><a name="StoppableThread-start"><strong>start</strong></a>(self)</dt><dd><tt>Start the thread's activity.<br>
|
|
<br>
|
|
It must be called at most once per thread object. It arranges for the<br>
|
|
object's <a href="#func_timeout.StoppableThread-run">run</a>() method to be invoked in a separate thread of control.<br>
|
|
<br>
|
|
This method will raise a RuntimeError if called more than once on the<br>
|
|
same thread object.</tt></dd></dl>
|
|
|
|
<hr>
|
|
Data descriptors inherited from <a href="threading.html#Thread">threading.Thread</a>:<br>
|
|
<dl><dt><strong>__dict__</strong></dt>
|
|
<dd><tt>dictionary for instance variables (if defined)</tt></dd>
|
|
</dl>
|
|
<dl><dt><strong>__weakref__</strong></dt>
|
|
<dd><tt>list of weak references to the object (if defined)</tt></dd>
|
|
</dl>
|
|
<dl><dt><strong>daemon</strong></dt>
|
|
<dd><tt>A boolean value indicating whether this thread is a daemon thread.<br>
|
|
<br>
|
|
This must be set before start() is called, otherwise RuntimeError is<br>
|
|
raised. Its initial value is inherited from the creating thread; the<br>
|
|
main thread is not a daemon thread and therefore all threads created in<br>
|
|
the main thread default to daemon = False.<br>
|
|
<br>
|
|
The entire Python program exits when no alive non-daemon threads are<br>
|
|
left.</tt></dd>
|
|
</dl>
|
|
<dl><dt><strong>ident</strong></dt>
|
|
<dd><tt>Thread identifier of this thread or None if it has not been started.<br>
|
|
<br>
|
|
This is a nonzero integer. See the get_ident() function. Thread<br>
|
|
identifiers may be recycled when a thread exits and another thread is<br>
|
|
created. The identifier is available even after the thread has exited.</tt></dd>
|
|
</dl>
|
|
<dl><dt><strong>name</strong></dt>
|
|
<dd><tt>A string used for identification purposes only.<br>
|
|
<br>
|
|
It has no semantics. Multiple threads may be given the same name. The<br>
|
|
initial name is set by the constructor.</tt></dd>
|
|
</dl>
|
|
</td></tr></table>
|
|
</body></html> |