/*!
\defgroup PPLGroupThreads Threads

Ein Thread ist ein sequentieller Abarbeitungslauf eines Prozesses und teilt sich mit den anderen
vorhandenen Threads (multithreading) des zugehörigen Prozesses eine Reihe von Betriebsmitteln,
nämlich das Codesegment, das Datensegment und die verwendeten Dateideskriptoren. Allerdings bewahrt
jeder Thread seinen eigenen Befehlszähler und seinen eigenen Stack. Durch die gemeinsame Nutzung des
Speicherbereichs kann es natürlich auch zu Konflikten kommen. Diese müssen durch den Einsatz von
Synchronisationsmechanismen (\ref PPLGroupThreadsMutex) aufgelöst werden.

\see http://de.wikipedia.org/wiki/Thread_%28Informatik%29


\defgroup PPLGroupThreadsMutex Mutex
\ingroup PPLGroupThreads
\brief Mutexes stellen ein Low-Level-Interface für die Synchronisation von Threads dar. Mit ihnen
    kann verhindert werden, dass mehrere Threads versuchen gleichzeitig auf die gleichen Daten
    zuzugreifen.
 

Das (oder der) Mutex (Abk. für engl. Mutual Exclusion, „wechselseitiger Ausschluss“) bezeichnet Verfahren,
mit denen verhindert wird, dass nebenläufige Prozesse bzw. Threads gleichzeitig auf Daten zugreifen und
so unter Umständen inkonsistente Zustände herbeiführen. Dieses Konzept ist von zentraler Bedeutung sowohl
für Systeme, deren Software in Threads abläuft, als auch für konkurrierend ablaufende Prozesse im
Allgemeinen, beispielsweise quasigleichzeitige Zugriffe auf ein Datenbanksystem aus mehreren
unabhängigen Clients. Das Konzept wird auch als Prozess- oder Thread-Synchronisation bezeichnet.
In vielen Programmiersprachen heißen auch die für die Synchronisation benötigten Objekte Mutexe.

\see http://de.wikipedia.org/wiki/Mutex


\defgroup PPLGroupThreadsPriority Thread-Prioritäten
\ingroup PPLGroupThreads
\brief Ein Thread kann verschiedene Prioritäten haben, die bestimmen, wieviel Rechenzeit ihm
    zugesprochen wird.


\section ThreadsPriority_Class Klassen
Ein Thread kann in eine von 4 Grundklassen eingeordnet werden, die bestimmen, mit welcher Priorität
er ausgeführt werden soll:
\li THREAD_CLASS::IDLE
\li THREAD_CLASS::NORMAL (der Default)
\li THREAD_CLASS::HIGH
\li THREAD_CLASS::REALTIME

Zur Zeit wird dieses Feature noch nicht verwendet!

\section ThreadsPriority_Priority Priorität
Zusätzlich kann noch ein Feintuning vorgenommen werden, bei dem die Priorität des Threads
festgelegt wird:
\li THREAD_PRIORITY::LOWEST\n
    Der Thread hat die niedrigste Priorität
\li THREAD_PRIORITY::BELOW_NORMAL\n
    Der Thread hat eine etwas niedrigere Priorität wie normal
\li THREAD_PRIORITY::NORMAL\n
    Der Thread hat normale Priorität
\li THREAD_PRIORITY::ABOVE_NORMAL:\n
    Der Thread hat eine etwas höhere Priorität wie normal
\li THREAD_PRIORITY::HIGHEST\n
    Der Thread hat die höchste Priorität
    
Mit folgenden Funktionen kann die Priorität eines Threads gelesen oder verändert werden:
    

\defgroup PPLGroupThreadsStacksize Thread-Stackgröße
\ingroup PPLGroupThreads
\brief Die Größe des Stacks verändern


Die Größe des Stacks wird vom Betriebssystem vorgegeben und sollte in den meisten Fällen
ausreichen. Manchmal ist er allerdings für die vorgesehene Anwendung zu klein (sehr viele
Rekursive Aufrufe) oder zu groß. Daher ist es möglich vor dem Starten des Threads die Größe
des Stacks zu verändern.

\defgroup PPLGroupThreadsStarten Threads starten
\ingroup PPLGroupThreads
\brief Zeigt, wie ein Thread gestartet wird

Um einen Thread zu starten, sind mehrere Schritte erforderlich.
\li Zuerst muß der Anwender eine eigene Klasse erstellen und diese von ppl6::CThread ableiten
\li Die Klasse des Anwenders muß eine Funktion "ThreadMain" enthalten, die den auszuführenden
Code enthält.
\li Diese muß in regelmäßigen Abständen die Funktion CThread::ThreadShouldStop aufrufen, um
zu prüfen, ob der Thread sich beenden soll.
\li Der Thread selbst wird dann von Hauptprogramm aus über die Funktion CThread::ThreadStart()
gestartet.

Beispiel:

\include CThread_ThreadMain.cpp


\defgroup PPLGroupThreadsCThreadPool Threads in einem Pool verwalten
\ingroup PPLGroupThreads
\brief Threads in einem Pool verwalten.


Wenn man mit mehreren Threads arbeitet, kann es sinnvoll sein diese zu gruppieren und in einem
Pool zusammenzufassen. Der Pool hat den Vorteil, dass alle Threads mit nur einem einzigen Befehl
gestoppt oder gelöscht werden können.


*/

