Somewhat generic queue processing class to establish a producer consumer queue.
More...
#include <buffer.h>
Inheritance diagram for ThreadQueue:
Collaboration diagram for ThreadQueue:
Data Structures
Public Types
Public Member Functions
Create instance of our queue and give it a process priority.
More...
void
post (const void *data, unsigned len)
Put some unspecified data into this queue.
More...
Enable setting of mutex name for deadlock debug.
More...
Entering a
Mutex locks the mutex for the current thread.
More...
Future abi will use enter/leave/test members.
More...
Future abi will use enter/leave/test members.
More...
Future abi will use enter/leave/test members.
More...
Tries to lock the mutex for the current thread.
More...
Leaving a mutex frees that mutex for use by another thread.
More...
When a new thread is created, it does not begin immediate execution.
More...
Start a new thread as "detached".
More...
Gets the pointer to the
Thread class which created the current thread object.
More...
Suspends execution of the selected thread.
More...
Resumes execution of the selected thread.
More...
Used to retrieve the cancellation mode in effect for the selected thread.
More...
Verifies if the thread is still running or has already been terminated but not yet deleted.
More...
Check if this thread is detached.
More...
Blocking call which unlocks when thread terminates.
More...
Tests to see if the current execution context is the same as the specified thread object.
More...
Get system thread numeric identifier.
More...
Get the name string for this thread, to use in debug messages.
More...
Wait is used to keep a thread held until the semaphore counter is greater than 0.
More...
Posting to a semaphore increments its current value and releases the first thread waiting for the semaphore if it is currently at 0.
More...
Call it after a deferred cancellation to avoid deadlocks.
More...
Static Public Member Functions
Enable or disable deadlock debugging.
More...
Set base stack limit before manual stack sizes have effect.
More...
Yields the current thread's CPU time slice to allow another thread to begin immediate execution.
More...
Get exception mode of the current thread.
More...
Set exception mode of the current thread.
More...
This is used to help build wrapper functions in libraries around system calls that should behave as cancellation points but don't.
More...
This is used to restore a cancel block.
More...
Protected Types
Protected Member Functions
A thread that is self terminating, either by invoking
exit() or leaving it's
run(), will have this method called.
More...
End of dequeing, we expect the queue is empty for now.
More...
A derivable method to call when the timout is expired.
More...
Virtual callback method to handle processing of a queued data items.
More...
Set the name of the current thread.
More...
The initial method is called by a newly created thread when it starts execution.
More...
Since
getParent() and
getThread() only refer to an object of the
Thread "base" type, this virtual method can be replaced in a derived class with something that returns data specific to the derived class that can still be accessed through the pointer returned by
getParent() and
getThread().
More...
When a thread terminates, it now sends a notification message to the parent thread which created it.
More...
Used to wait for a join or cancel, in place of explicit exit.
More...
test a cancellation point for deferred thread cancellation.
More...
Sets thread cancellation mode.
More...
Sets the thread's ability to be suspended from execution.
More...
Used by another thread to terminate the current thread.
More...
clear parent thread relationship.
More...
Protected Attributes
Private Member Functions
All threads execute by deriving the Run method of
Thread.
More...
Detailed Description
Somewhat generic queue processing class to establish a producer consumer queue.
This may be used to buffer cdr records, or for other purposes where an in-memory queue is needed for rapid posting. This class is derived from Mutex and maintains a linked list. A thread is used to dequeue data and pass it to a callback method that is used in place of "run" for each item present on the queue. The conditional is used to signal the run thread when new data is posted.
This class was changed by Angelo Naselli to have a timeout on the queue
in memory data queue interface.
- Author
- David Sugar dyfet.nosp@m.@ost.nosp@m.el.co.nosp@m.m
Definition at line 261 of file buffer.h.
Member Typedef Documentation
Member Enumeration Documentation
How work cancellation.
| Enumerator |
|---|
| cancelInitial |
used internally, do not use
|
| cancelDeferred |
exit thread on cancellation pointsuch as yield
|
| cancelImmediate |
exit befor cancellation
|
| cancelDisabled |
ignore cancellation
|
| cancelManual |
unimplemented (working in progress)
- Todo:
- implement
|
| cancelDefault |
default you should use this for compatibility instead of deferred
|
Definition at line 1108 of file thread.h.
How work suspend.
| Enumerator |
|---|
| suspendEnable |
suspend enabled
|
| suspendDisable |
suspend disabled, Suspend do nothing
|
Definition at line 1122 of file thread.h.
How to raise error.
| Enumerator |
|---|
| throwNothing |
continue without throwing error
|
| throwObject |
throw object that cause error (throw this)
|
| throwException |
throw an object relative to error
|
Definition at line 1099 of file thread.h.
Constructor & Destructor Documentation
ThreadQueue::ThreadQueue
(
const char *
id,
int
pri,
size_t
stack = 0
)
Create instance of our queue and give it a process priority.
- Parameters
-
id queue ID.
pri process priority.
stack stack size.
virtual ThreadQueue::~ThreadQueue
(
)
virtual |
Member Function Documentation
void Thread::clrParent
(
void
)
inlineprotectedinherited |
clear parent thread relationship.
Definition at line 1295 of file thread.h.
Start a new thread as "detached".
This is an alternative start() method that resolves some issues with later glibc implimentations which incorrectly impliment self-detach.
- Returns
- error code if execution fails.
- Parameters
-
start optional starting semaphore to alternately use.
void Mutex::enter
(
void
)
inlineinherited |
Future abi will use enter/leave/test members.
Definition at line 263 of file thread.h.
static
Cancel Thread::enterCancel
(
void
)
staticinherited |
This is used to help build wrapper functions in libraries around system calls that should behave as cancellation points but don't.
- Returns
- saved cancel type.
void Mutex::enterMutex
(
void
)
inherited |
Entering a Mutex locks the mutex for the current thread.
This also can be done using the ENTER_CRITICAL macro or by using the ++ operator on a mutex.
- See Also
- leaveMutex
void Thread::exit
(
void
)
protectedinherited |
Used to properly exit from a Thread derived run() or initial() method.
Terminates execution of the current thread and calls the derived classes final() method.
static void Thread::exitCancel
(
Cancel
cancel )
staticinherited |
This is used to restore a cancel block.
- Parameters
-
cancel type that was saved.
virtual void ThreadQueue::final
(
)
protectedvirtual |
A thread that is self terminating, either by invoking exit() or leaving it's run(), will have this method called.
It can be used to self delete the current object assuming the object was created with new on the heap rather than stack local, hence one may often see final defined as "delete this" in a derived thread class. A final method, while running, cannot be terminated or cancelled by another thread. Final is called for all cancellation type (even immediate).
You can safe delete thread ("delete this") class on final, but you should exit ASAP (or do not try to call CommonC++ methods...)
- Note
- A thread cannot delete its own context or join itself. To make a thread that is a self running object that self-deletes, one has to detach the thread by using detach() instead of start().
- See Also
- exit
-
run
Reimplemented from Thread.
void Semaphore::force_unlock_after_cancellation
(
)
inherited |
Call it after a deferred cancellation to avoid deadlocks.
From PTHREAD_COND_TIMEDWAIT(3P): A condition wait (whether timed or not) is a cancellation point. When the cancelability enable state of a thread is set to PTHREAD_CANCEL_DEFERRED, a side effect of acting upon a cancellation request while in a condition wait is that the mutex is (in effect) re-acquired before calling the first cancellation cleanup handler.
static
Thread* Thread::get
(
void
)
staticinherited |
Cancel Thread::getCancel
(
void
)
inlineinherited |
Used to retrieve the cancellation mode in effect for the selected thread.
- Returns
- cancellation mode constant.
Definition at line 1419 of file thread.h.
static
Throw Thread::getException
(
void
)
staticinherited |
Get exception mode of the current thread.
- Returns
- exception mode.
virtual void* Thread::getExtended
(
void
)
protectedvirtualinherited |
Since getParent() and getThread() only refer to an object of the Thread "base" type, this virtual method can be replaced in a derived class with something that returns data specific to the derived class that can still be accessed through the pointer returned by getParent() and getThread().
- Returns
- pointer to derived class specific data.
cctid_t Thread::getId
(
void
)
const
inherited |
Get system thread numeric identifier.
- Returns
- numeric identifier of this thread.
const char* Thread::getName
(
void
)
const
inlineinherited |
Get the name string for this thread, to use in debug messages.
- Returns
- debug name.
Definition at line 1463 of file thread.h.
Thread* Thread::getParent
(
void
)
inlineinherited |
Gets the pointer to the Thread class which created the current thread object.
- Returns
- a Thread *, or "(Thread *)this" if no parent.
Definition at line 1397 of file thread.h.
virtual void Thread::initial
(
void
)
protectedvirtualinherited |
The initial method is called by a newly created thread when it starts execution.
This method is ran with deferred cancellation disabled by default. The Initial method is given a separate handler so that it can create temporary objects on it's own stack frame, rather than having objects created on run() that are only needed by startup and yet continue to consume stack space.
- See Also
- run
-
final
Reimplemented in TCPSession, and UnixSession.
bool Thread::isDetached
(
void
)
const
inherited |
Check if this thread is detached.
- Returns
- true if the thread is detached.
bool Thread::isRunning
(
void
)
const
inherited |
Verifies if the thread is still running or has already been terminated but not yet deleted.
- Returns
- true if the thread is still executing.
bool Thread::isThread
(
void
)
const
inherited |
Tests to see if the current execution context is the same as the specified thread object.
- Returns
- true if the current context is this object.
void Thread::join
(
void
)
inherited |
Blocking call which unlocks when thread terminates.
void Mutex::leave
(
void
)
inlineinherited |
Future abi will use enter/leave/test members.
Definition at line 269 of file thread.h.
void Mutex::leaveMutex
(
void
)
inherited |
Leaving a mutex frees that mutex for use by another thread.
If the mutex has been entered (invoked) multiple times (recursivily) by the same thread, then it will need to be exited the same number of instances before it is free for re-use. This operation can also be done using the LEAVE_CRITICAL macro or by the – operator on a mutex.
- See Also
- enterMutex
void Mutex::nameMutex
(
const char *
name )
inlineinherited |
Enable setting of mutex name for deadlock debug.
- Parameters
-
name for mutex.
Definition at line 248 of file thread.h.
virtual void Thread::notify
(
Thread *
)
protectedvirtualinherited |
When a thread terminates, it now sends a notification message to the parent thread which created it.
The actual use of this notification is left to be defined in a derived class.
- Parameters
-
- the thread that has terminated.
virtual void ThreadQueue::onTimer
(
void
)
protectedvirtual |
A derivable method to call when the timout is expired.
void ThreadQueue::post
(
const void *
data,
unsigned
len
)
Put some unspecified data into this queue.
A new qd structure is created and sized to contain a copy of the actual content.
- Parameters
-
data pointer to data.
len size of data.
void Semaphore::post
(
void
)
inherited |
Posting to a semaphore increments its current value and releases the first thread waiting for the semaphore if it is currently at 0.
Interestingly, there is no support to increment a semaphore by any value greater than 1 to release multiple waiting threads in either pthread or the win32 API. Hence, if one wants to release a semaphore to enable multiple threads to execute, one must perform multiple post operations.
- See Also
- wait
void Thread::resume
(
void
)
inherited |
Resumes execution of the selected thread.
void ThreadQueue::run
(
void
)
privatevirtual |
All threads execute by deriving the Run method of Thread.
This method is called after Initial to begin normal operation of the thread. If the method terminates, then the thread will also terminate after notifying it's parent and calling it's Final() method.
- See Also
- Initial
Implements Thread.
virtual void ThreadQueue::runQueue
(
void *
data )
protectedpure virtual |
Virtual callback method to handle processing of a queued data items.
After the item is processed, it is deleted from memory. We can call multiple instances of runQueue in order if multiple items are waiting.
- Parameters
-
data item being dequed.
void Thread::setCancel
(
Cancel
mode )
protectedinherited |
Sets thread cancellation mode.
Threads can either be set immune to termination (cancelDisabled), can be set to terminate when reaching specific "thread cancellation points" (cancelDeferred) or immediately when Terminate is requested (cancelImmediate).
- Parameters
-
mode for cancellation of the current thread.
static void Mutex::setDebug
(
bool
mode )
inlinestaticinherited |
Enable or disable deadlock debugging.
- Parameters
-
mode debug mode.
Definition at line 240 of file thread.h.
static void Thread::setException
(
Throw
mode )
staticinherited |
Set exception mode of the current thread.
- Returns
- exception mode.
void Thread::setName
(
const char *
text )
protectedinherited |
Set the name of the current thread.
If the name is passed as NULL, then the default name is set (usually object pointer).
- Parameters
-
text name to use.
static void Thread::setStack
(
size_t
size = 0 )
inlinestaticinherited |
Set base stack limit before manual stack sizes have effect.
- Parameters
-
size stack size to set, or use 0 to clear autostack.
Definition at line 1347 of file thread.h.
void Thread::setSuspend
(
Suspend
mode )
protectedinherited |
Sets the thread's ability to be suspended from execution.
The thread may either have suspend enabled (suspendEnable) or disabled (suspendDisable).
- Parameters
-
mode for suspend.
void ThreadQueue::setTimer
(
timeout_t
timeout )
Set the queue timeout.
When the timer expires, the onTimer() method is called for the thread
- Parameters
-
timeout timeout in milliseconds.
A thread-safe sleep call.
On most Posix systems, "sleep()" is implimented with SIGALRM making it unusable from multipe threads. Pthread libraries often define an alternate "sleep" handler such as usleep(), nanosleep(), or nap(), that is thread safe, and also offers a higher timer resolution.
- Parameters
-
msec timeout in milliseconds.
When a new thread is created, it does not begin immediate execution.
This is because the derived class virtual tables are not properly loaded at the time the C++ object is created within the constructor itself, at least in some compiler/system combinations. The thread can either be told to wait for an external semaphore, or it can be started directly after the constructor completes by calling the start() method.
- Returns
- error code if execution fails.
- Parameters
-
start optional starting semaphore to alternately use.
virtual void ThreadQueue::startQueue
(
void
)
protectedvirtual |
Start of dequeing.
Maybe we need to connect a database or something, so we have a virtual...
virtual void ThreadQueue::stopQueue
(
void
)
protectedvirtual |
End of dequeing, we expect the queue is empty for now.
Maybe we need to disconnect a database or something, so we have another virtual.
void Thread::suspend
(
void
)
inherited |
Suspends execution of the selected thread.
Pthreads do not normally support suspendable threads, so the behavior is simulated with signals. On systems such as Linux that define threads as processes, SIGSTOP and SIGCONT may be used.
void Thread::sync
(
void
)
protectedinherited |
Used to wait for a join or cancel, in place of explicit exit.
void Thread::terminate
(
void
)
protectedinherited |
Used by another thread to terminate the current thread.
Termination actually occurs based on the current setCancel() mode. When the current thread does terminate, control is returned to the requesting thread. terminate() should always be called at the start of any destructor of a class derived from Thread to assure the remaining part of the destructor is called without the thread still executing.
bool Mutex::test
(
void
)
inlineinherited |
Future abi will use enter/leave/test members.
- Returns
- true if entered.
Definition at line 277 of file thread.h.
bool Thread::testCancel
(
void
)
protectedinherited |
test a cancellation point for deferred thread cancellation.
bool Mutex::tryEnterMutex
(
void
)
inherited |
Tries to lock the mutex for the current thread.
Behaves like enterMutex , except that it doesn't block the calling thread if the mutex is already locked by another thread.
- Returns
- true if locking the mutex was succesful otherwise false
- See Also
- enterMutex
-
leaveMutex
bool Semaphore::wait
(
timeout_t
timeout =
0 )
inherited |
Wait is used to keep a thread held until the semaphore counter is greater than 0.
If the current thread is held, then another thread must increment the semaphore. Once the thread is accepted, the semaphore is automatically decremented, and the thread continues execution.
The pthread semaphore object does not support a timed "wait", and hence to maintain consistancy, neither the posix nor win32 source trees support "timed" semaphore objects.
- Returns
- false if timed out
- Parameters
-
timeout period in milliseconds to wait
- See Also
- post
static void Thread::yield
(
void
)
staticinherited |
Yields the current thread's CPU time slice to allow another thread to begin immediate execution.
Field Documentation
bool ThreadQueue::started
protected |
The documentation for this class was generated from the following file:
Generated on Dec 21, 2017 for
commoncpp2-1.8.1,
ccrtp-1.7.2,
libzrtpcpp-2.3.4,
ccscript3-1.1.7,
ccaudio2-1.0.0 and
bayonne2-2.3.2
(after installation in /usr/local/)
by
doxygen 1.8.6