#include <KKThreadManager.h>

Inheritance diagram for KKB::KKThreadManager:

Public Member Functions
	KKThreadManager (const KKStr &_managerName, kkuint32 _maxNumThreads, MsgQueuePtr _msgQueue)

	~KKThreadManager ()

void	AddThread (KKThreadPtr _thread)

bool	AllThreadsTerminated ()

bool	AnyProcessorsCrashed ()

const bool &	Crashed () const

const bool &	DoneExecuting () const

void	KillAllRunningThreads ()

void	ManageThreads (bool &successful)

void	RequestShutdown ()

void	RequestTerminate ()

virtual void	Run ()

const bool &	ShutdownFlag () const

void	ShutdownProcessing (kkint32 miliSecsToWait)
	Shutdown all threads in a orderly way; observing prerequisite ordering. More...

void	TerminateProcessing ()

Public Member Functions inherited from KKB::KKThread
	KKThread (const KKStr &_threadName, KKThreadManagerPtr _threadManager, MsgQueuePtr _msgQueue)

virtual	~KKThread ()

void	AddShutdownPrerequistite (KKThreadPtr _thread)
	Specify threads that must stop before this thread is started. More...

void	AddStartPrerequistite (KKThreadPtr _thread)
	Specify threads that must start before this thread is started. More...

VolConstBool &	CancelFlag () const

bool	Crashed () const

void	Crashed (bool _crashed)

const KKStr &	ExceptionText () const

void	ExceptionText (const KKStr &_exceptionText)

KKStrListPtr	GetMsgs ()

void	Kill ()
	stops the running thread and frees the thread handle More...

kkint32	MemoryConsumedEstimated ()

KKB::MsgQueuePtr	MsgQueue ()

bool	OkToShutdown () const

bool	OkToStart () const

VolConstBool &	ShutdownFlag () const

void	ShutdownThread ()

void	Start (ThreadPriority _priority, bool &successful)

ThreadStatus	Status () const

void	Status (ThreadStatus _status)

const KKStr &	StatusStr () const

VolConstBool &	TerminateFlag () const

virtual void	TerminateFlagChanged ()
	Will be called whenever the value of 'terminateFlag' is changed; derived classes should override this method if they need to be aware that the terminaeFlag has changed. This give them a chance to let other objects/methods know that the flag has changed. More...

void	TerminateThread ()

kkint32	ThreadId () const

const KKStr &	ThreadName () const

bool	ThreadStillProcessing () const

void	WaitForThreadToStop (kkuint32 maxTimeToWait)
	Called by separate thread; will stay in loop until the thread controlled by this instance shutdown or it waited the 'maxTimeToWait'. More...

Additional Inherited Members
Public Types inherited from KKB::KKThread
typedef KKThread *	KKThreadPtr

enum	ThreadPriority : int { ThreadPriority::Null, ThreadPriority::Low, ThreadPriority::Normal, ThreadPriority::High }

enum	ThreadStatus : int { ThreadStatus::Null, ThreadStatus::NotStarted, ThreadStatus::Starting, ThreadStatus::Running, ThreadStatus::Stopping, ThreadStatus::Stopped }

Static Public Member Functions inherited from KKB::KKThread
static const KKStr &	ThreadStatusToStr (ThreadStatus)

Protected Member Functions inherited from KKB::KKThread
void	AddMsg (KKStrPtr msg)

void	AddMsg (const KKStr &msg)

bool	ShutdownOrTerminateRequested ()

bool	ThereIsACircularReferenceShutdown (KKThreadPtr _thread) const

bool	ThereIsACircularReferenceStart (KKThreadPtr _thread) const

Detailed Description

There are three ways to stop Thread processing with the first being the most graceful and the last being the most abrupt.
1) 'ShutdownProcessing'  The preferred method;  each thread is flagged for 'Shutdown' after all its prerequisite shutdown threads 
   have shutdown.
2) 'TerminateProcessing' Similar to 'ShutdownProcessing' except the prerequisites are not checked; each thread is immediately flagged
   to Terminate which indicates to the thread that it is to cease all processing and exit while releasing all resources.
3) 'KillAllRunningThreads' A last resort;  you would call this if for some reason threads are not terminating on there own.

Definition at line 37 of file KKThreadManager.h.

Constructor & Destructor Documentation

KKThreadManager::KKThreadManager	(	const KKStr &	_managerName,
		kkuint32	_maxNumThreads,
		MsgQueuePtr	_msgQueue
	)

Definition at line 23 of file KKThreadManager.cpp.

References KKB::KKThread::KKThread(), and KKB::KKThreadList::KKThreadList().

                                   :
   KKThread (_managerName, NULL, _msgQueue),
   crashed            (false),
   doneExecuting      (false),
   maxNumThreads      (_maxNumThreads),
   shutdownFlag       (false),
   shutdownRequested  (false),
   terminateFlag      (false),
   terminateRequested (false),
   threads            (NULL)
 
 {
   threads = new KKThreadList (true);
 }

KKThreadManager::~KKThreadManager ( )

Definition at line 44 of file KKThreadManager.cpp.

 {
   delete  threads;
   threads = NULL;
 }

Member Function Documentation

void KKThreadManager::AddThread ( KKThreadPtr _thread )

Add thread that is to be managed; will take ownership

Definition at line 52 of file KKThreadManager.cpp.

References KKB::KKThreadList::KKThreadList().

 {
   if  (!threads)
     threads = new KKThreadList (true);
 
   threads->PushOnBack (_thread);
 }

bool KKThreadManager::AllThreadsTerminated ( )

Definition at line 280 of file KKThreadManager.cpp.

References KKB::KKThread::Status(), and KKB::KKThread::Stopped.

 {
   bool  allThreadsTerminated = true;
 
   if  (threads)
   {
     KKThreadList::const_iterator  idx;
     for  (idx = threads->begin ();  idx != threads->end ();  ++idx)
     {
       KKThreadPtr  t = *idx;
       if  (t->Status () != KKThread::ThreadStatus::Stopped)
       {
         allThreadsTerminated = false;
         break;
       }
     }
   }
 
   return  allThreadsTerminated;
 }  /* AllThreadsTerminated */

bool KKThreadManager::AnyProcessorsCrashed ( )

Definition at line 255 of file KKThreadManager.cpp.

References KKB::KKThread::Crashed().

Referenced by ManageThreads().

 {
   bool  anyProcessorsCrashed = false;
 
   if  (threads)
   {
     KKThreadList::iterator  idx;
     for  (idx = threads->begin ();  idx != threads->end ();  ++idx)
     {
       KKThreadPtr  t = *idx;
       if  (t->Crashed ())
       {
         anyProcessorsCrashed = true;
         break;
       }
     }
   }
 
   crashed = anyProcessorsCrashed;
 
   return  anyProcessorsCrashed;
 }  /* AnyProcessorsCrash */

const bool& KKB::KKThreadManager::Crashed ( ) const

inline

Definition at line 48 of file KKThreadManager.h.

48 {return crashed;}

const bool& KKB::KKThreadManager::DoneExecuting ( ) const

inline

Definition at line 49 of file KKThreadManager.h.

49 {return doneExecuting;}

void KKThreadManager::KillAllRunningThreads ( )

Will STOP ALL running threads; NOT Grace-full;

Definition at line 185 of file KKThreadManager.cpp.

References KKB::KKThread::Kill().

Referenced by ShutdownProcessing().

 {
   if  (!threads)
     return;
 
   KKThreadList::iterator  idx;
   for  (idx = threads->begin ();   idx != threads->end ();  ++idx)
   {
     KKThreadPtr  thread = *idx;
     thread->Kill ();
   }
 }  /* KillAllRunningThreads*/

void KKThreadManager::ManageThreads ( bool & successful )

Definition at line 305 of file KKThreadManager.cpp.

References AnyProcessorsCrashed(), KKB::osSleep(), ShutdownProcessing(), and TerminateProcessing().

 {
   successful= false;
   if (!threads)
     return;
 
   StartThreads (successful);
   if  (!successful)
     return;
 
 
   while  (true)
   {
     if  (shutdownRequested)
     {
       shutdownRequested = false;
       ShutdownProcessing (0);
       break;
     }
 
     else if  (terminateRequested)
     {
       terminateRequested = false;
       TerminateProcessing ();
       break;
     }
 
     else
     {
       osSleep (0.05f);
     }
   }
 
 
   if  (AnyProcessorsCrashed ())
   {
     AddMsg ("One or more processors crashed!!!");
     crashed = true;
   }
 }  /* ManageThreads */

void KKThreadManager::RequestShutdown ( )

Definition at line 62 of file KKThreadManager.cpp.

 {
   shutdownRequested = true;
 }

void KKThreadManager::RequestTerminate ( )

Definition at line 68 of file KKThreadManager.cpp.

 {
   terminateRequested = true;
 }

void KKThreadManager::Run ( )

virtual

Reimplemented from KKB::KKThread.

Definition at line 348 of file KKThreadManager.cpp.

349 {

350 }

const bool& KKB::KKThreadManager::ShutdownFlag ( ) const

inline

Definition at line 47 of file KKThreadManager.h.

47 {return shutdownFlag;}

void KKThreadManager::ShutdownProcessing ( kkint32 miliSecsToWait )

Shutdown all threads in a orderly way; observing prerequisite ordering.

Definition at line 93 of file KKThreadManager.cpp.

References KillAllRunningThreads(), KKB::KKThread::NotStarted, KKB::KKThread::Null, KKB::KKThread::OkToShutdown(), KKB::osSleep(), KKB::KKThread::Running, KKB::KKThread::ShutdownFlag(), KKB::KKThread::ShutdownThread(), KKB::KKThread::Starting, KKB::KKThread::Status(), KKB::KKThread::Stopped, and KKB::KKThread::Stopping.

Referenced by ManageThreads().

 {
   shutdownFlag = true;
 
   if  (!threads)
     return;
 
   kkint32  numMiliSecsWaited = 0;
   shutdownFlag = true;
 
   kkint32  lastNumThreadsRunning = 0;
   kkint32  lastNumThreadsStopped = 0;
 
   bool  allTreadsAreShutdown = false;
 
   while  (!allTreadsAreShutdown)
   {
     allTreadsAreShutdown = true;
     kkint32  numThreadsRunning = 0;
     kkint32  numThreadsStopped = 0;
 
     KKThreadList::iterator  idx;
     for  (idx = threads->begin ();  idx != threads->end ();  ++idx)
     {
       KKThreadPtr  thread = *idx;
 
       switch  (thread->Status ())
       {
       case  KKThread::ThreadStatus::Null:
         break;
 
       case  KKThread::ThreadStatus::NotStarted:
       case  KKThread::ThreadStatus::Stopped:
         // Nothing to do;  this thread is not running,
         ++numThreadsStopped;
         break;
 
       case  KKThread::ThreadStatus::Stopping:
         allTreadsAreShutdown = false;
         ++numThreadsRunning;
         break;
 
       case  KKThread::ThreadStatus::Running:
         {
           allTreadsAreShutdown = false;
           if  (!(thread->ShutdownFlag ()))
           {
             if  (thread->OkToShutdown ())
             {
               thread->ShutdownThread ();
               numMiliSecsWaited = 0;
             }
           }
           ++numThreadsRunning;
         }
         break;
 
       case  KKThread::ThreadStatus::Starting:
         // Have to let it finish starting before we can flag it to shutdown.
         ++numThreadsRunning;
         break;
       }  /* End of Switch */
     }
 
     if  ((numThreadsRunning != lastNumThreadsRunning)  ||
          (numThreadsStopped != lastNumThreadsStopped)
         )
     {
       // The status of one or more threads changed;  can reset the 'numMiliSecsWaited' clock.
       numMiliSecsWaited = 0;
     }
 
     if  (!allTreadsAreShutdown)
     {
       if  ((miliSecsToWait > 0)  &&  (numMiliSecsWaited > miliSecsToWait))
       {
         // The shutdown process is taking longer than the 'miliSecsToWait' parameter will allow for;  we need to terminate
         // all running threads now.
         KillAllRunningThreads ();
         break;
       }
       else
       {
         osSleep (0.01f);
         numMiliSecsWaited += 10;
       }
     }
   }
 }  /* ShutdownProcessing */

void KKThreadManager::TerminateProcessing ( )

Flag all All running threads to Terminate ASAP and release all allocated resources.

Definition at line 76 of file KKThreadManager.cpp.

References KKB::KKThread::TerminateThread().

Referenced by ManageThreads().

 {
   terminateFlag = true;
   if  (threads)
   {
     KKThreadList::iterator  idx;
     for  (idx = threads->begin ();  idx != threads->end ();  ++idx)
     {
       KKThreadPtr  thread = *idx;
       thread->TerminateThread ();
     }
   }
 }  /* TerminateProcessing */

The documentation for this class was generated from the following files:

C:/Users/Kurt/GitHub/KSquareLibraries/KKBase/KKThreadManager.h
C:/Users/Kurt/GitHub/KSquareLibraries/KKBase/KKThreadManager.cpp

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation