Go to the documentation of this file.
43 #ifndef _UCOMMON_THREAD_H_
44 #define _UCOMMON_THREAD_H_
46 #ifndef _UCOMMON_CPR_H_
50 #ifndef _UCOMMON_ACCESS_H_
54 #ifndef _UCOMMON_TIMERS_H_
58 #ifndef _UCOMMON_MEMORY_H_
62 #ifndef _UCOMMON_CONDITION_H_
92 virtual void _share(
void) __OVERRIDE;
94 virtual void _lock(
void) __OVERRIDE;
96 virtual void _unlock(
void) __OVERRIDE;
98 virtual void _unshare(
void) __OVERRIDE;
101 typedef autoshared<RWLock> autoreader;
103 typedef autoexclusive<RWLock> autowriter;
142 void set(
const void *
object);
165 static bool lock(
const void *
object, timeout_t timeout = Timer::inf);
205 void set(
const void *
object);
228 static bool lock(
const void *
object, timeout_t timeout = Timer::inf);
241 bool modify(timeout_t timeout = Timer::inf);
248 bool access(timeout_t timeout = Timer::inf);
284 mutable pthread_cond_t cond;
287 mutable pthread_mutex_t mutex;
379 virtual void _lock(
void) __OVERRIDE;
380 virtual void _unlock(
void) __OVERRIDE;
383 typedef autoexclusive<RecursiveMutex> autolock;
462 __DELETE_COPY(
Mutex);
465 mutable pthread_mutex_t mlock;
467 virtual void _lock(
void) __OVERRIDE;
468 virtual void _unlock(
void) __OVERRIDE;
471 typedef autoexclusive<Mutex> autolock;
487 pthread_mutex_lock(&mlock);
494 pthread_mutex_lock(&mlock);
501 pthread_mutex_unlock(&mlock);
508 pthread_mutex_unlock(&mlock);
515 inline static void acquire(pthread_mutex_t *lock) {
516 pthread_mutex_lock(lock);
523 inline static void release(pthread_mutex_t *lock) {
524 pthread_mutex_unlock(lock);
576 void set(
const void *
object);
595 inline operator bool()
const {
596 return object != NULL;
599 inline bool operator!()
const {
600 return object == NULL;
605 class autoprotect :
public AutoProtect
610 inline autoprotect(
const T *
object) :
AutoProtect(object) {};
612 inline void set(
const T *
object) {
616 inline void release() {
620 inline autoprotect& operator=(
const T*
object) {
625 inline T* operator->()
const {
626 return static_cast<T*
>(object);
629 inline T& operator*()
const {
630 __THROW_DEREF(
object);
631 return *(
static_cast<T*
>(object));
658 enum {R_UNUSED} reserved;
690 __DELETE_COPY(Local);
695 virtual void release(
void *instance) = 0;
697 virtual void *allocate();
704 void set(
void *instance);
708 inline void clear() {
731 static void sleep(timeout_t timeout);
744 virtual void run(
void) = 0;
790 static bool equal(pthread_t thread1, pthread_t thread2);
796 static pthread_t
self(void);
798 inline operator bool()
const {
802 inline bool operator!()
const {
806 inline bool isRunning(
void)
const {
810 static void release(
void);
832 volatile bool running;
834 volatile bool joining;
857 virtual void run(
void) __OVERRIDE = 0;
920 virtual void run(
void) __OVERRIDE = 0;
952 #define __AUTOLOCK(x) autolock __autolock__(x)
953 #define __AUTOPROTECT(x) AutoProtect __autolock__(x)
954 #define __SYNC(x) for(bool _sync_flag_ = Mutex::protect(x); _sync_flag_; _sync_flag_ = !Mutex::release(x))
Private heaps, pools, and associations.
void set(const void *object)
Set guard to mutex lock a new object.
static bool protect(const void *pointer)
Specify pointer/object/resource to guard protect.
AutoProtect(const void *object)
Construct a guard for a specific object.
Realtime timers and timer queues.
static void sleep(timeout_t timeout)
Sleep current thread for a specified time period.
Guard class to apply scope based mutex locking to objects.
void join(void)
Join thread with parent.
ReusableObject * next(ReusableObject *object)
Get next reusable object in the pool.
void release(void)
Prematurely release a guard.
void acquire(void)
Acquire mutex lock.
bool modify(timeout_t timeout=Timer::inf)
Request modify (write) access through the lock.
static void yield(void)
Yield execution context of the current thread.
static void release(pthread_mutex_t *lock)
Convenience function to release os native mutex lock directly.
void wait(void)
A simple wait until triggered.
bool sync(void)
Wait while locked.
Common namespace for all ucommon objects.
ReusableObject * getNext(void)
Get next effective reusable object when iterating.
bool is_active(void) const
Check if running.
TimedEvent(time_t timeout)
Create event handler and timer set to trigger a timeout.
writer(const void *object)
Construct a guard for a specific object.
virtual void run(void)=0
Abstract interface for thread context run method.
static bool lock(const void *object, timeout_t timeout=Timer::inf)
Shared access to an arbitrary object.
~AutoProtect()
Release mutex when guard falls out of scope.
static void indexing(unsigned size)
Specify hash table size for guard protection.
Generic non-recursive exclusive lock class.
bool access(timeout_t timeout=Timer::inf)
Request shared (read) access through the lock.
Event notification to manage scheduled realtime threads.
ReusableAllocator()
Initialize reusable allocator through a conditional.
Generic smart pointer class.
bool is_active(void) const
Check if running.
virtual ~Thread()
Destroy thread object, thread-specific data, and execution context.
RecursiveMutex()
Create rexlock.
void set(const void *object)
Set guard to mutex lock a new object.
static bool release(const void *object)
Release an arbitrary object that has been protected by a rwlock.
void release(void)
Release or decrease locking.
void unlock(void)
Release acquired lock.
static bool release(const void *pointer)
Specify a pointer/object/resource to release.
Apply automatic scope based access locking to objects.
static bool lock(const void *object, timeout_t timeout=Timer::inf)
Write protect access to an arbitrary object.
Class for resource bound memory pools between threads.
Apply automatic scope based exclusive locking to objects.
reader()
Create an unitialized instance of guard.
void release(void)
Release acquired lock.
An exclusive locking access interface base.
void reset(void)
Reset triggered conditional.
void lock(void)
Acquire mutex lock.
virtual bool is_active(void) const
Check if running.
TimedEvent(timeout_t timeout)
Create event handler and timer set to trigger a timeout.
TimedEvent(void)
Create event handler and timer for timing of events.
TimedEvent timedevent_t
Convenience type for using timed events.
Locking protocol classes for member function automatic operations.
virtual ~JoinableThread()
Delete child thread.
~TimedEvent()
Destroy timer and release pending events.
A generic and portable implementation of Read/Write locking.
void lock(void)
Lock the object for wait or to manipulate derived data.
virtual void run(void)=0
Abstract interface for thread context run method.
void map(void)
Map thread for get method.
void operator=(const void *pointer)
Set guard to read lock a new object.
static void acquire(pthread_mutex_t *lock)
Convenience function to acquire os native mutex lock directly.
Reusable objects for forming private heaps.
The conditional rw seperates scheduling for optizming behavior or rw locks.
~writer()
Release mutex when guard falls out of scope.
static size_t cache(void)
Get cache line size.
reader(const void *object)
Construct a guard for a specific object.
void setPriority(void)
Set thread priority without disrupting scheduling if possible.
virtual void run(void)=0
Abstract interface for thread context run method.
void lock(void)
Acquire or increase locking.
DetachedThread(size_t size=0)
Create a detached thread with a known context stack size.
static void policy(int polid)
Used to specify scheduling policy for threads above priority "0".
void background(void)
Start execution of child context as background thread.
void operator=(const void *pointer)
Set guard to read lock a new object.
void release(void)
Release the lock.
void start(int priority=0)
Start execution of detached context.
AutoProtect()
Create an unitialized instance of guard.
void set(const void *object)
Set guard to mutex lock a new object.
void start(int priority=0)
Start execution of child context.
An abstract class for defining classes that operate as a thread.
Mutex()
Create a mutex lock.
virtual void exit(void)
Exit the thread context.
RWLock rwlock_t
Convenience type for using read/write locks.
bool wait(timeout_t timeout)
Wait to be signalled or until timer expires.
~reader()
Release mutex when guard falls out of scope.
bool lock(timeout_t timeout)
Timed lock request.
static void concurrency(int level)
Set concurrency level of process.
~DetachedThread()
Destroys object when thread context exits.
static Thread * get(void)
Get mapped thread object.
Condition classes for thread sychronization and timing.
static void indexing(unsigned size)
Specify hash table size for guard protection.
Mutex mutex_t
Convenience type for using exclusive mutex locks.
Common base class for all objects that can be formed into a linked list.
RecursiveMutex rexlock_t
Convenience type for using recursive exclusive locks.
writer()
Create an unitialized instance of guard.
Timer class to use when scheduling realtime events.
JoinableThread(size_t size=0)
Create a joinable thread with a known context stack size.
An exclusive locking protocol interface base.
void release(void)
Prematurely release a guard.
void release(void)
Prematurely release a guard.
static bool equal(pthread_t thread1, pthread_t thread2)
Determine if two thread identifiers refer to the same thread.
Thread(size_t stack=0)
Create a thread object that will have a preset stack size.
virtual void _share(void)
Access interface to share lock the object.
void exit(void)
Exit context of detached thread.
A child thread object that may be joined by parent.
void release(ReusableObject *object)
Release resuable object.
The conditional is a common base for other thread synchronizing classes.
RWLock()
Create an instance of a rwlock.
~Mutex()
Destroy mutex lock, release waiting threads.
Portable recursive exclusive lock.
void signal(void)
Signal pending event.
A detached thread object that is stand-alone.
void release(void)
Release the object lock after waiting.
static void init(void)
Used to initialize threading library.