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))
static void concurrency(int level)
Set concurrency level of process.
Private heaps, pools, and associations.
TimedEvent(time_t timeout)
Create event handler and timer set to trigger a timeout.
RecursiveMutex()
Create rexlock.
Generic smart pointer class.
Locking protocol classes for member function automatic operations.
void release(ReusableObject *object)
Release resuable object.
writer()
Create an unitialized instance of guard.
static void indexing(unsigned size)
Specify hash table size for guard protection.
Guard class to apply scope based mutex locking to objects.
virtual bool is_active(void) const
Check if running.
void release(void)
Prematurely release a guard.
An exclusive locking access interface base.
virtual void _share(void)
Access interface to share lock the object.
void exit(void)
Exit context of detached thread.
RWLock rwlock_t
Convenience type for using read/write locks.
static void acquire(pthread_mutex_t *lock)
Convenience function to acquire os native mutex lock directly.
Apply automatic scope based exclusive locking to objects.
void operator=(const void *pointer)
Set guard to read lock a new object.
static bool lock(const void *object, timeout_t timeout=Timer::inf)
Shared access to an arbitrary object.
Condition classes for thread sychronization and timing.
void signal(void)
Signal pending event.
static void sleep(timeout_t timeout)
Sleep current thread for a specified time period.
Reusable objects for forming private heaps.
The conditional rw seperates scheduling for optizming behavior or rw locks.
void set(const void *object)
Set guard to mutex lock a new object.
RecursiveMutex rexlock_t
Convenience type for using recursive exclusive locks.
~Mutex()
Destroy mutex lock, release waiting threads.
AutoProtect(const void *object)
Construct a guard for a specific object.
A child thread object that may be joined by parent.
ReusableObject * next(ReusableObject *object)
Get next reusable object in the pool.
static void policy(int polid)
Used to specify scheduling policy for threads above priority "0".
ReusableObject * getNext(void)
Get next effective reusable object when iterating.
static void init(void)
Used to initialize threading library.
bool modify(timeout_t timeout=Timer::inf)
Request modify (write) access through the lock.
ReusableAllocator()
Initialize reusable allocator through a conditional.
writer(const void *object)
Construct a guard for a specific object.
An abstract class for defining classes that operate as a thread.
~TimedEvent()
Destroy timer and release pending events.
Realtime timers and timer queues.
Common base class for all objects that can be formed into a linked list.
void unlock(void)
Release acquired lock.
static bool protect(const void *pointer)
Specify pointer/object/resource to guard protect.
Generic non-recursive exclusive lock class.
Timer class to use when scheduling realtime events.
JoinableThread(size_t size=0)
Create a joinable thread with a known context stack size.
bool lock(timeout_t timeout)
Timed lock request.
bool access(timeout_t timeout=Timer::inf)
Request shared (read) access through the lock.
DetachedThread(size_t size=0)
Create a detached thread with a known context stack size.
void lock(void)
Acquire mutex lock.
void set(const void *object)
Set guard to mutex lock a new object.
static void release(pthread_mutex_t *lock)
Convenience function to release os native mutex lock directly.
Portable recursive exclusive lock.
static bool release(const void *object)
Release an arbitrary object that has been protected by a rwlock.
static bool release(const void *pointer)
Specify a pointer/object/resource to release.
void release(void)
Prematurely release a guard.
TimedEvent(void)
Create event handler and timer for timing of events.
Common namespace for all ucommon objects.
Class for resource bound memory pools between threads.
~reader()
Release mutex when guard falls out of scope.
static bool lock(const void *object, timeout_t timeout=Timer::inf)
Write protect access to an arbitrary object.
virtual ~Thread()
Destroy thread object, thread-specific data, and execution context.
void set(const void *object)
Set guard to mutex lock a new object.
void release(void)
Release or decrease locking.
TimedEvent(timeout_t timeout)
Create event handler and timer set to trigger a timeout.
Event notification to manage scheduled realtime threads.
virtual void run(void)=0
Abstract interface for thread context run method.
void release(void)
Release the lock.
~AutoProtect()
Release mutex when guard falls out of scope.
Mutex mutex_t
Convenience type for using exclusive mutex locks.
void release(void)
Release acquired lock.
Mutex()
Create a mutex lock.
void acquire(void)
Acquire mutex lock.
static Thread * get(void)
Get mapped thread object.
bool is_active(void) const
Check if running.
void release(void)
Prematurely release a guard.
bool is_active(void) const
Check if running.
reader()
Create an unitialized instance of guard.
void start(int priority=0)
Start execution of child context.
reader(const void *object)
Construct a guard for a specific object.
~writer()
Release mutex when guard falls out of scope.
void map(void)
Map thread for get method.
static bool equal(pthread_t thread1, pthread_t thread2)
Determine if two thread identifiers refer to the same thread.
Apply automatic scope based access locking to objects.
Thread(size_t stack=0)
Create a thread object that will have a preset stack size.
void lock(void)
Lock the object for wait or to manipulate derived data.
void operator=(const void *pointer)
Set guard to read lock a new object.
void background(void)
Start execution of child context as background thread.
bool wait(timeout_t timeout)
Wait to be signalled or until timer expires.
void join(void)
Join thread with parent.
AutoProtect()
Create an unitialized instance of guard.
virtual void run(void)=0
Abstract interface for thread context run method.
static size_t cache(void)
Get cache line size.
void start(int priority=0)
Start execution of detached context.
An exclusive locking protocol interface base.
void wait(void)
A simple wait until triggered.
A generic and portable implementation of Read/Write locking.
void lock(void)
Acquire or increase locking.
bool sync(void)
Wait while locked.
void setPriority(void)
Set thread priority without disrupting scheduling if possible.
virtual void run(void)=0
Abstract interface for thread context run method.
TimedEvent timedevent_t
Convenience type for using timed events.
void release(void)
Release the object lock after waiting.
The conditional is a common base for other thread synchronizing classes.
void reset(void)
Reset triggered conditional.
static void indexing(unsigned size)
Specify hash table size for guard protection.
static void yield(void)
Yield execution context of the current thread.
~DetachedThread()
Destroys object when thread context exits.
RWLock()
Create an instance of a rwlock.
A detached thread object that is stand-alone.
virtual void exit(void)
Exit the thread context.
virtual ~JoinableThread()
Delete child thread.