scistag.common.mt.task_thread.TaskThread¶

class TaskThread(name)[source]¶

Bases: ManagedThread

Helper class to create threads which shall

Parameters: name (str) – The thread’s name as shown in the debugger

Methods

`add_task`	Adds a task to be executed
`force_kill`	Throws an interrupt exception on the thread to request its termination.
`force_kill_thread`	Tries to kill a thread by raising an exception.
`getName`
`get_active_threads`	Returns a list of all running, managed threads
`isDaemon`
`is_alive`	Return whether the thread is alive.
`join`	Wait until the thread terminates.
`raise_exception_async`	Raises an exception in another thread, e.g.
`run`	Executes run_loop until `terminate()` is called from another thread.
`run_loop`	Override this method with your own task handling method.
`run_task`	Runs a task added via `add_task()`.
`setDaemon`
`setName`
`start`	Starts the thread
`terminate`	Signals the termination flag.
`unregister_thread`	Removes this thread from the global registry

Attributes

`__annotations__`
`__dict__`
`__doc__`
`__module__`
`__weakref__`	list of weak references to the object (if defined)
`_initialized`
`_managed_threads`	List of all running threads
`_mt_access_lock`	Access lock to shared, global class variables
`daemon`	A boolean value indicating whether this thread is a daemon thread.
`ident`	Thread identifier of this thread or None if it has not been started.
`name`	A string used for identification purposes only.
`native_id`	Native integral thread ID of this thread, or None if it has not been started.
`_task_event`	The event handler which shall be triggered for each event arriving
`_tasks`	The list of tasks to execute
`_turn_time`	The event outbreak time, fallback is an event trigger should fail

_delete()¶: Remove current thread from the dict of currently running threads.

_set_tstate_lock()¶: Set a lock object which will be released by the interpreter when the underlying thread state (see pystate.h) gets deleted.

add_task(task)[source]¶

Adds a task to be executed

Parameters: task (Any) – The task to be executed via run_task

force_kill()¶

Throws an interrupt exception on the thread to request its termination.

Warning: This should really be the absolute last solution to get rid of a thread, e.g. an infinite running Flask server. For all other threads use terminate() and join().

Return type: bool
Returns: True on success.

classmethod force_kill_thread(thread)¶

Tries to kill a thread by raising an exception.

Parameters: thread (Thread) – The thread which we try to kill.
Return type: bool
Returns: True on success

classmethod get_active_threads()¶

Returns a list of all running, managed threads

Return type: list[ManagedThread]
Returns: The list of active threads

is_alive()¶

Return whether the thread is alive.

This method returns True just before the run() method starts until just after the run() method terminates. See also the module function enumerate().

join(timeout=None)¶

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 is_alive() 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.

static raise_exception_async(ident, exception_class)¶

Raises an exception in another thread, e.g. to kill it such as interrupting a Flask server’s endless loop.

Parameters

ident – The thread’s ident (e.g. thread.ident)
exception_class – The type of the exception to raise, e.g. KeyboardException.

run()¶

Executes run_loop until terminate() is called from another thread.

Return type: None

run_loop()[source]¶: Override this method with your own task handling method.

run_task(task)[source]¶

Runs a task added via add_task().

Parameters: task (Any) – The task to execute

start()¶

Starts the thread

Return type: None

terminate()[source]¶

Signals the termination flag.

Signals the termination event. If you have other events, e.g for your task list, override this method and trigger them from here as well.

unregister_thread()¶: Removes this thread from the global registry

_access_lock¶: The lock to access the thread’s data

_managed_threads: list[scistag.common.mt.managed_thread.ManagedThread] = []¶: List of all running threads

_mt_access_lock = <scistag.common.mt.stag_lock.StagLock object>¶: Access lock to shared, global class variables

_task_event¶: The event handler which shall be triggered for each event arriving

_tasks: list¶: The list of tasks to execute

_turn_time¶: The event outbreak time, fallback is an event trigger should fail

property daemon¶

A boolean value indicating whether this thread is a daemon thread.

This must be set before start() is called, otherwise RuntimeError is raised. Its initial value is inherited from the creating thread; the main thread is not a daemon thread and therefore all threads created in the main thread default to daemon = False.

The entire Python program exits when only daemon threads are left.

property ident¶

Thread identifier of this thread or None if it has not been started.

This is a nonzero integer. See the get_ident() function. Thread identifiers may be recycled when a thread exits and another thread is created. The identifier is available even after the thread has exited.

property name¶

A string used for identification purposes only.

It has no semantics. Multiple threads may be given the same name. The initial name is set by the constructor.

property native_id¶

Native integral thread ID of this thread, or None if it has not been started.

This is a non-negative integer. See the get_native_id() function. This represents the Thread ID as reported by the kernel.

terminate_event¶: Event to be flagged when the thread shall terminate

thread_name¶: The thread’s name (as visible in the debugger)