W
Soooooo
für alle die das hier vielleicht verfolgen oder über die Suche mit einem ähnlichen Problem hier landen, ich hab es für mich zumindest gelößt.
Und das beste ist mit recht guter Preformance.
Super Simpel.
Und ganz ohne Events... (<-- Blöden S#+#!"# Dinger da....)
Hätte ich mir echt früher überlegen sollen, hätte mir eine menge Zeit und
Frust ersparrt. Na Ja hinterher ist man immer schlauer.
Ist dennoch schon extrem, wie langsam das Programm mit den Event wurde
ThreadStatus Header
#if !defined THREADSTATUS_H
#define THREADSTATUS_H
#include "resource.h"
#include <iostream.h>
#include <windows.h>
#include <direct.h>
#include "Mutex.h"
#include "GlobalData.h"
using namespace std;
class TThreadStatus
{
public:
TThreadStatus(bool DEBUG =true);
void ThreadAlsAktivAnmelden(bool ThreadAnmeldeStatus, int FahrzeugNummer);
void ThreadWartetAufSynch(bool ThreadAnmeldeStatus ,int FahrzeugNummer);
void ThreadAusloggen(bool ThreadZustand , int FahrzuegNummer);
void StatusReset();
bool SynchThreadStart(int FahrzuegNummer);
TGlobalData *GlobalData;
int FahrzeugeImSystem;
int RechenDurchlauf;
int ThreadAktiv ;
int ThreadWartend ;
int ThreadInsgesammt ;
bool ErsteThreadAnmeldung;
bool SperreGeradeDurchlaufe;
bool SperreUngeradeDurchlaufe;
HWND TS_Dialog;
bool TS_Dialog_Offen;
TMutex Mutex;
private:
bool SynchDebug;
void OnlineAuswertung(HWND hwnd);
bool FileAuswertung(int FahrzeugNummer);w
TMutex TestMutex;
};
#endif
ThreadStatus CPP
#include "ThreadStatus.h"
TThreadStatus::TThreadStatus(bool Debug)
// Konstruktor
{
this->SynchDebug = true;
this->ErsteThreadAnmeldung = false;
this->ThreadInsgesammt =0;
this->ThreadAktiv =0;
this->ThreadWartend =0;
this->RechenDurchlauf =1;
this->SperreGeradeDurchlaufe = true;
this->SperreUngeradeDurchlaufe = false;
}
void TThreadStatus::ThreadAlsAktivAnmelden(bool ThreadAnmeldeStatus ,int FahrzeugNummer)
// Thread Im Status System auf Aktiv setzen
{
Mutex.EnterMutex();
if(this->ErsteThreadAnmeldung == false)
this->ErsteThreadAnmeldung = true;
if(ThreadAnmeldeStatus == false)
{
this->ThreadInsgesammt++;
Sleep(100);
}
//if((ThreadWartend >0) && (ThreadAnmeldeStatus == true))
// this->ThreadWartend--;
this->ThreadAktiv++;
this->FileAuswertung(FahrzeugNummer);
Mutex.LeaveMutex();
}
void TThreadStatus::ThreadWartetAufSynch(bool ThreadAnmeldeStatus , int FahrzeugNummer )
// Thread in wartezustand bis zur herstellunfg der Synchonisation versetzen
{
Mutex.EnterMutex();
if(this->ErsteThreadAnmeldung == false)
ErsteThreadAnmeldung = true;
if(ThreadAnmeldeStatus == false)
{
this->ThreadInsgesammt++;
Sleep(100);
}
if((this->ThreadAktiv >0) && (ThreadAnmeldeStatus == true))
ThreadAktiv--;
this->ThreadWartend++;
this->FileAuswertung(FahrzeugNummer);
if(this->SynchThreadStart(FahrzeugNummer) == FALSE)
{
bool test;
if(this->RechenDurchlauf % 2 == 0)
{
TestMutex.EnterMutex();
test = this->SperreGeradeDurchlaufe;
TestMutex.LeaveMutex();
Mutex.LeaveMutex();
while(test != true)
{
TestMutex.EnterMutex();
test = this->SperreGeradeDurchlaufe;
TestMutex.LeaveMutex();
Sleep(1);
}
}
else
{
TestMutex.EnterMutex();
test = this->SperreUngeradeDurchlaufe;
TestMutex.LeaveMutex();
Mutex.LeaveMutex();
while(test != true)
{
TestMutex.EnterMutex();
test = this->SperreUngeradeDurchlaufe;
TestMutex.LeaveMutex();
Sleep(1);
}
}
}
else
Mutex.LeaveMutex();
}
bool TThreadStatus::SynchThreadStart(int FahrzeugNummer)
// Gibt alle angehaltenen Threads für einen weiteren Berechnungsdurchgang frei
{
if((this->ThreadInsgesammt == this->ThreadWartend) && (this->ThreadAktiv == 0)
&& (this->ErsteThreadAnmeldung==true) && (this->ThreadInsgesammt == this->FahrzeugeImSystem))
{
// Tauschen der Akt. liste mit der Use Liste
GlobalData->GDListenTauschen();
TestMutex.EnterMutex();
if(this->RechenDurchlauf % 2 == 0)
// Sicherstellen das die Akt. Sperre erst freigegeben wird wenn die andere wieder gesetzt ist
{
this->SperreUngeradeDurchlaufe = false;
this->SperreGeradeDurchlaufe = true;
}
else
{
this->SperreGeradeDurchlaufe = false;
this->SperreUngeradeDurchlaufe = true;
}
TestMutex.LeaveMutex();
this->RechenDurchlauf++;
this->ThreadWartend = 0;
this->FileAuswertung(FahrzeugNummer);
return TRUE;
}
return FALSE;
}
void TThreadStatus::StatusReset()
// Status in NULL Zustand zurückversetzen
{
Mutex.EnterMutex();
ThreadInsgesammt =0;
ThreadAktiv =0;
ThreadWartend =0;
RechenDurchlauf = 1;
TestMutex.EnterMutex();
this->SperreGeradeDurchlaufe = true;
this->SperreUngeradeDurchlaufe = false;
TestMutex.LeaveMutex();
Mutex.LeaveMutex();
}
void TThreadStatus::ThreadAusloggen(bool ThreadZustand ,int FahrzeugNummer)
// Abmelden eines Threads aus dem Status
{ // was ist mit thread die terminiert werden ???? hmmm noch nicht beachtet
Mutex.EnterMutex();
ThreadInsgesammt--;
if(this->ThreadInsgesammt == 0)
this->ErsteThreadAnmeldung = false;
if(ThreadZustand == true)
if(this->ThreadAktiv > 0)
this->ThreadAktiv--;
else
if(this->ThreadWartend > 0 )
this->ThreadWartend--;
this->FileAuswertung(FahrzeugNummer);
Mutex.LeaveMutex();
}
bool TThreadStatus::FileAuswertung(int FahrzeugNummer)
{
if(this->SynchDebug == true)
{
FILE *pf;
string sDateipfad = "\\TS.txt";
const char * cDateipfad;
string Pfad;
int curdrive;
char path[600];
curdrive = _getdrive();
_getdcwd( curdrive, path, 600 );
string Programmpfad = path;
Pfad += Programmpfad;
Pfad += sDateipfad;
cDateipfad = Pfad.c_str();
pf = fopen( cDateipfad, "a");
if (! pf)
return FALSE;
fprintf(pf,"===================FzN:%d\n",FahrzeugNummer);
fprintf(pf,"Aktiv: %d\n", this->ThreadAktiv);
fprintf(pf,"Wartend: %d\n",this->ThreadWartend);
fprintf(pf,"Insgesammt: %d\n",this->ThreadInsgesammt);
fprintf(pf,"SWABs: %d\n", this->RechenDurchlauf-1);
fclose(pf);
return TRUE;
}
return FALSE;
}
OK zugegeben meine Rechtschreibung ist manchmal (öhm) komisch, einfach ignorrieren
So nochmal Danke an alle die sich das Problem angeschaut haben und vielleicht den ein oder anderen Gedanken dran mit verschwendet haben.
