Basisklasse für einen Thread der seine Arbeit endlos bis zum Abbruch ausführt.
Mehr ...
#include <EuRepeatingThread.h>
Basisklasse für einen Thread der seine Arbeit endlos bis zum Abbruch ausführt.
In Unterklassen muß lediglich die virtuale Methode RepeatingThread::work() überschrieben werden.
- Achtung
- Der Thread muss nach dem start mit cancel() vor dem Aufruf des Destruktors beendet werden!
- Autor
- Helmut Jakoby
- Copyright
- © 2010 Helmut Jakoby
◆ EuTHREADERROR
Fehlerbereich = -10301 bis -10400
Aufzählungswerte |
---|
EuTHREAD_ERR_NO_THREAD | -10301:
Es ist ein erwarteter Thread nicht vorhanden bzw. nicht gestartet.
|
EuTHREAD_ERR_THREAD_ALREADY_WORKING | -10302:
Der Threads ist schon gestartet.
|
EuTHREAD_ERR_THREAD_BREAK_COUNT_LESS_THAN_ZERO | -10303:
Der Thread wurde zu oft aus dem 'Schlaf' geweckt.
|
EuTHREAD_ERR_UNKNOWN | -10400:
Undefinierter Fehler.
|
◆ ORDER
Einem RepeatingThread können nach dem Start Anweisungen übergeben werden.
Aufzählungswerte |
---|
eUNDEFINED | Undefiniert.
|
eDO_WORK | Thread soll arbeiten.
|
eEXIT | Thread soll sich beenden.
|
◆ STATUS
Um den Thread steuern zu können, ist es förderlich, wenn der Arbeitsstatus bekannt ist.
Aufzählungswerte |
---|
eAT_THE_START | Der Threads hat noch nicht gearbeitet.
|
eWORKING | Der Threads ist am arbeiten.
|
ePAUSING | Der Threads pausiert.
|
eENDING | Der Threads beendet gerade seiner Arbeit.
|
eCOMPLETED | Der Threads ist mit seiner Arbeit fertig.
|
◆ RepeatingThread() [1/2]
eut::RepeatingThread::RepeatingThread |
( |
| ) |
|
◆ ~RepeatingThread()
virtual eut::RepeatingThread::~RepeatingThread |
( |
| ) |
|
|
virtual |
Destruktor.
- Achtung
- Es muss vor dem Destruktor die Methode cancel() aufgerufen werden! Da cancel() virtual, kann dieses nicht im dtor ausgeführt werden.
◆ RepeatingThread() [2/2]
Der Copy-Konstruktor steht nicht zur Verfügung.
◆ cancel()
virtual void eut::RepeatingThread::cancel |
( |
| ) |
|
|
virtual |
◆ finishBreak()
virtual void eut::RepeatingThread::finishBreak |
( |
| ) |
|
|
virtual |
◆ getBreakCounter()
int eut::RepeatingThread::getBreakCounter |
( |
| ) |
|
◆ getOrder()
ORDER eut::RepeatingThread::getOrder |
( |
| ) |
|
|
protected |
Liefert die letzte übergebene Anweisung.
- Rückgabe
- Die aktuelle Anweisungen.
◆ getStatus()
STATUS eut::RepeatingThread::getStatus |
( |
| ) |
|
|
protected |
Liefert den aktuellen Status.
- Rückgabe
- Der gesetzte Status.
◆ isInExclusiveAccess()
bool eut::RepeatingThread::isInExclusiveAccess |
( |
| ) |
const |
◆ operator=()
Zuweisungsoperator steht nicht zur Verfügung.
◆ setExclusiveAccess()
void eut::RepeatingThread::setExclusiveAccess |
( |
| ) |
|
◆ setStatus()
void eut::RepeatingThread::setStatus |
( |
STATUS | eStatus | ) |
|
|
protected |
Setzt den Status.
- Parameter
-
[in] | eStatus | Der zu setzende Status. |
◆ signalInput()
void eut::RepeatingThread::signalInput |
( |
| ) |
|
Beendet das Warten ohne Tätigkeit, welches durch waitForInput() initiiert wurde.
◆ start()
virtual int eut::RepeatingThread::start |
( |
| ) |
|
|
virtual |
Startet den Thread.
- Rückgabe
- Ein Rückgabewert < 0 zeigt einen Fehler an. Z.B. wenn Thread schon läuft.
- Achtung
- Der Thread muss nach start() vor dem Destruktor mittels cancel() beendet werden.
◆ status()
Liefert den Status des Threads.
- Rückgabe
- Der Status.
◆ takeABreak()
virtual void eut::RepeatingThread::takeABreak |
( |
| ) |
|
|
virtual |
Initiiert ein pausieren des Threads um die Bearbeitung zu unterbrechen. Muss durch finishBreak() wieder beendet werden.
- Zu beachten
- Da der Thread die Bearbeitung nur überspringt (also noch läuft) kann ein echtes Aussetzen des Threads durch Nutzung der Methode waitForInput() in der Methode work() der abgeleiteten Klasse erreicht werden.
Erneute Implementation in tcp::ReceiverTransmitter.
◆ testCancel()
bool eut::RepeatingThread::testCancel |
( |
| ) |
|
Liefert true, wenn Thread beendet wurde.
- Rückgabe
- s.o.
◆ threadWork()
void eut::RepeatingThread::threadWork |
( |
| ) |
|
|
protected |
Diese Methode, vom Thread ausgeführt, ruft in einer Schleife die Methode work() auf.
◆ toOrder()
void eut::RepeatingThread::toOrder |
( |
ORDER | eOrder | ) |
|
|
protected |
Übernimmt die übergebene Anweisung.
- Parameter
-
[in] | eOrder | Die zu setzende Anweisungen. |
◆ unsetExclusiveAccess()
void eut::RepeatingThread::unsetExclusiveAccess |
( |
| ) |
|
◆ waitForInput()
void eut::RepeatingThread::waitForInput |
( |
| ) |
|
Läßt den Thread an definierter Position ohne Tätigkeit warten. Muss durch signalInput() wieder beendet werden.
- Zu beachten
- Diese Methode kann in der Methode work() einer abgeleiteten Klasse genutz werden, um den Thread aussetzen zu lasse. Der Thread wacht durch signalInput() wieder auf, was auch in der abgeleiteten Klasse initiiert werden muss.
◆ work()
virtual void eut::RepeatingThread::work |
( |
| ) |
|
|
protectedpure virtual |
◆ m_BreakCondVar
std::condition_variable eut::RepeatingThread::m_BreakCondVar |
|
private |
◆ m_BreakMutex
std::mutex eut::RepeatingThread::m_BreakMutex |
|
private |
◆ m_eOrder
ORDER eut::RepeatingThread::m_eOrder |
|
private |
Einem Thread kann ein Befehl gegeben werden der hier gesetzt wird.
◆ m_eStatus
STATUS eut::RepeatingThread::m_eStatus |
|
private |
◆ m_ExclusiveAccessSection
◆ m_iBreakCounter
int eut::RepeatingThread::m_iBreakCounter |
|
private |
Wenn ein RepeatingThread pausieren soll, wird dieser Zähler incrementiert. Wenn der Thread wieder aufwachen soll, wird dieser Zähler decrementiert. Bei 0 wird der Thread wieder aufgeweckt.
Damit wird ein geschachteltes schlafen legen und auwecken ermöglicht.
◆ m_iDataReady
int eut::RepeatingThread::m_iDataReady |
|
private |
Um "lost wakeup" und "spurious wakeups" zu vermeiden, ist diese Variable notwendig.
◆ m_InputCondVar
std::condition_variable eut::RepeatingThread::m_InputCondVar |
|
private |
◆ m_pThread
std::thread* eut::RepeatingThread::m_pThread |
|
private |
◆ m_WaitMutex
std::mutex eut::RepeatingThread::m_WaitMutex |
|
private |
Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei: