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
int	count = count
	currentThread = current_thread
	get_ident = _thread.get_ident
	limit = limit
	Lock = _allocate_lock
	mon = RLock()
	queue = deque()
	quota = quota
	rc = Condition(self.mon)
	ThreadError = _thread.error
	TIMEOUT_MAX = _thread.TIMEOUT_MAX
	wc = Condition(self.mon)

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

int count = count

currentThread

currentThread = current_thread

get_ident

get_ident = _thread.get_ident

limit

limit = limit

Lock

Lock = _allocate_lock

mon

mon = RLock()

queue

queue = deque()

quota

quota = quota

rc

rc = Condition(self.mon)

ThreadError

ThreadError = _thread.error

TIMEOUT_MAX

TIMEOUT_MAX = _thread.TIMEOUT_MAX

wc

wc = Condition(self.mon)