Panda3D
Loading...
Searching...
No Matches
Classes | Functions | Variables
direct.stdpy.threading2 Namespace Reference

Classes

class  _BoundedSemaphore
 
class  _Condition
 
class  _DummyThread
 
class  _Event
 
class  _MainThread
 
class  _RLock
 
class  _Semaphore
 
class  _Timer
 
class  _Verbose
 
class  Thread
 

Functions

 _pickSomeNonDaemonThread ()
 
 _test ()
 try: from thread import _local as local except ImportError: from _threading_local import local
 
 active_count ()
 
 BoundedSemaphore (*args, **kwargs)
 
 Condition (*args, **kwargs)
 
 current_thread ()
 
 enumerate ()
 
 Event (*args, **kwargs)
 
 main_thread ()
 
 RLock (*args, **kwargs)
 
 Semaphore (*args, **kwargs)
 
 setprofile (func)
 
 settrace (func)
 
 Timer (*args, **kwargs)
 

Variables

dict _active = {}
 
 _active_limbo_lock = _allocate_lock()
 
 _allocate_lock = _thread.allocate_lock
 
dict _limbo = {}
 
 _main_thread = _MainThread()
 
 _profile_hook = None
 
 _shutdown = _main_thread._exitfunc
 
 _sleep = core.Thread.sleep
 
 _start_new_thread = _thread.start_new_thread
 
 _trace_hook = None
 
bool _VERBOSE = False
 
 activeCount = active_count
 
 count
 
 currentThread = current_thread
 
 get_ident = _thread.get_ident
 
 limit
 
 Lock = _allocate_lock
 
 mon
 
 queue
 
 quota
 
 rc
 
 ThreadError = _thread.error
 
 TIMEOUT_MAX = _thread.TIMEOUT_MAX
 
 wc
 

Detailed Description

 This module reimplements Python's native threading module using Panda
threading constructs.  It's designed as a drop-in replacement for the
threading module for code that works with Panda; it is necessary because
in some compilation models, Panda's threading constructs are
incompatible with the OS-provided threads used by Python's thread
module.

Unlike threading.py, this module is a more explicit implementation of
Python's threading model, designed to more precisely emulate Python's
standard threading semantics.  In fact, this is a bald-face copy of
Python's threading module from Python 2.5, with a few lines at the top
to import Panda's thread reimplementation instead of the system thread
module, and so it is therefore layered on top of Panda's thread
implementation. 

Function Documentation

◆ _pickSomeNonDaemonThread()

_pickSomeNonDaemonThread ( )
protected

◆ _test()

_test ( )
protected

try: from thread import _local as local except ImportError: from _threading_local import local

◆ active_count()

active_count ( )

◆ BoundedSemaphore()

BoundedSemaphore ( * args,
** kwargs )

◆ Condition()

Condition ( * args,
** kwargs )

◆ current_thread()

current_thread ( )

◆ enumerate()

enumerate ( )

◆ Event()

Event ( * args,
** kwargs )

◆ main_thread()

main_thread ( )
Return the main thread object.
In normal conditions, the main thread is the thread from which the
Python interpreter was started.

◆ RLock()

RLock ( * args,
** kwargs )

◆ Semaphore()

Semaphore ( * args,
** kwargs )

◆ setprofile()

setprofile ( func)

◆ settrace()

settrace ( func)

◆ Timer()

Timer ( * args,
** kwargs )

Variable Documentation

◆ _active

dict _active = {}
protected

◆ _active_limbo_lock

_active_limbo_lock = _allocate_lock()
protected

◆ _allocate_lock

_allocate_lock = _thread.allocate_lock
protected

◆ _limbo

dict _limbo = {}
protected

◆ _main_thread

_main_thread = _MainThread()
protected

◆ _profile_hook

_profile_hook = None
protected

◆ _shutdown

_shutdown = _main_thread._exitfunc
protected

◆ _sleep

_sleep = core.Thread.sleep
protected

◆ _start_new_thread

_start_new_thread = _thread.start_new_thread
protected

◆ _trace_hook

_trace_hook = None
protected

◆ _VERBOSE

bool _VERBOSE = False
protected

◆ activeCount

activeCount = active_count

◆ count

count

◆ currentThread

currentThread = current_thread

◆ get_ident

get_ident = _thread.get_ident

◆ limit

limit

◆ Lock

◆ mon

mon

◆ queue

queue

◆ quota

quota

◆ rc

rc

◆ ThreadError

ThreadError = _thread.error

◆ TIMEOUT_MAX

TIMEOUT_MAX = _thread.TIMEOUT_MAX

◆ wc

wc