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
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)