@elmut19
TerminateThread birgt so einige Gefahren in sich, das solltest du anders lösen. Du könntest eine Klasse um den Thread bauen, damit du eine Abbruchbedingung implementieren kannst:
class ScopedLock
{
CRITICAL_SECTION& CriticalSection_ ;
public:
ScopedLock( CRITICAL_SECTION cs ) :
CriticalSection( cs )
{
// to do: Fehlerbehandlung
EnterCriticalSection( &CriticalSection_ );
}
~ScopedLock ()
{
// to do: Fehlerbehandlung
LeaveCriticalSection( &CriticalSection_ );
}
// Objekt darf nicht kopierbar sein
ScopedLock( ScopedLock const& ) = delete;
ScopedLock( ScopedLock&& ) = delete;
ScopedLock& operator=( ScopedLock const& ) = delete;
ScopedLock& operator=( ScopedLock&& ) = delete;
};
class Win32Thread
{
CRITICAL_SECTION CriticalSection_;
HANDLE Thread_ = 0;
bool Terminated_ = false;
public:
Win32Thread()
{
// to do: Fehlerbehandlung
CreateCriticalSection( &CriticalSection );
}
~WinThread()
{
DestroyCriticalSection( &CriticalSection );
}
void terminate()
{
ScopedLock lock( CriticalSection_ );
Terminated_ true;
}
bool terminated() const
{
ScopedLock lock( CriticalSection_ );
return Terminated_;
}
void join()
{
// auf Threadende warten
WaitForSingleObject( Thread_, INFINITE );
}
void run()
{
while( !terminated() )
{
if( !terminated() ) draw_step_1();
if( !terminated() ) draw_step_2();
if( !terminated() ) draw_step_...();
if( !terminated() ) draw_step_n();
}
}
}
So könnte ein Gerüst für ein Win32 Thread aussehen. Du kannst das auch mit std::thread lösen, nur kenne ich mich mit denen kaum aus. Die Idee ist, dass dein Thread so lange läuft, bis du ihm per terminate() signalisierst, dass er sich zum nächstmöglichen Zeitpunkt beenden soll (=> die run() Methode verlässt). Mit join() wartest du darauf, dass er das tut.
In der run() Methode solltest du in kürzeren Abständen prüfen, ob der Thread beendet werden muss, damit der Thread nicht zu träge auf die Abbruchaufforderung reagiert.
Der Übersicht halber ist das Ganze ohne Netz und doppelten Boden.
