Panda3D

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

## Classes
class | BoundedSemaphore
class | Condition
class | Event
class | ExternalThread
class | Lock
class | MainThread
class | RLock
class | Semaphore
class | Thread
class | ThreadBase
class | Timer

## Functions
| _create_thread_wrapper (t, threadId)
| _test ()
| active_count ()
| current_thread ()
| enumerate ()
| main_thread ()
| setprofile (func)
| settrace (func)
| stack_size (size=None)

## Variables
| _newname = _thread._newname
| _setprofile_func = None
| _settrace_func = None
| activeCount = active_count
int | count = count
| currentThread = current_thread
| limit = limit
| local = _thread._local
| mon = Lock(name = "BoundedQueue.mon")
| 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.

    This module implements the threading module with a thin layer over
    Panda's threading constructs.  As such, the semantics are close to,
    but not precisely, the semantics documented for Python's standard
    threading module.  If you really do require strict adherence to
    Python's semantics, see the threading2 module instead.

    However, if you don't need such strict adherence to Python's original
    semantics, this module is probably a better choice.  It is likely to
    be slighly faster than the threading2 module (and even slightly faster
    than Python's own threading module).  It is also better integrated
    with Panda's threads, so that Panda's thread debug mechanisms will be
    easier to use and understand.

    It is permissible to mix-and-match both threading and threading2
    within the same application.

## Function Documentation

## ◆ _create_thread_wrapper()

_create_thread_wrapper | ( |  | t,
|  |  | threadId )
| protected

     Creates a thread wrapper for the indicated external thread.

## ◆ _test()

_test | ( |  | ) |
| protected

## ◆ active_count()

active_count | ( |  | ) |

## ◆ current_thread()

current_thread | ( |  | ) |

## ◆ enumerate()

enumerate | ( |  | ) |

## ◆ main_thread()

main_thread | ( |  | ) |

## ◆ setprofile()

setprofile | ( |  | func | ) |

## ◆ settrace()

settrace | ( |  | func | ) |

## ◆ stack_size()

stack_size | ( |  | size = None | ) |

## Variable Documentation

## ◆ _newname

_newname = _thread._newname
| protected

## ◆ _setprofile_func

_setprofile_func = None
| protected

## ◆ _settrace_func

_settrace_func = None
| protected

## ◆ activeCount

activeCount = active_count

## ◆ count

int count = count

## ◆ currentThread

currentThread = current_thread

## ◆ limit

limit = limit

## ◆ local

local = _thread._local

## ◆ mon

mon = Lock(name = "BoundedQueue.mon")

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