Mein Programm besitzt einen Fensterthread und einen Workerthread. Das ganze läuft einwandfrei, bis ich das Programm beende. Dann nämlich muss der Fensterthread den Workerthread beenden. Zwar tritt der Fehler relativ selten auf, aber auch das ist nicht annehmbar.
Ich habe die ganze Sache synchronisiert und meiner Meinung nach dürfte der Fensterthread nicht fortfahren, bis der Workerthread terminiert worden ist.
Ich skiziere noch kurz den Ablauf beim Beenden:
Die erst DLL beendet über den Fensterthread den Worker Thread, der in der zweiten DLL läuft, dann wird die 2. DLL entladen. Danach löscht der der Fensterthread die gemeinsamen Resourcen und entladet danach die erste DLL.
Trotz dieser Reihenfolge greift der Worker Thread manchmal auf die gemeinsamen Resourcen zu, nachdem er beendet worden sein sollte. Wie kann das sein?! Ich synchronisiere ja die ganze Sache, so dass der Haupt Thread ja gar nicht die Resourcen löschen kann, bevor der Worker Thread die Schleife beendet hat, wo er auf die Resourcen zugreifen kann!!!

Fensterthread :

cs.Lock(); //CCriticalSection
die = true; 
cs.Unlock(); 
WaitForSingleObject(thread, INFINITE); //thread == Workerthread (HANDLE)

Workerthread:

while(true) { 
  cs.Lock(); 
  if(die) { 
    cs.Unlock(); 
    return; 
  } 
  //Zugriff auf gem. Resourcen 
  cs.Unlock(); 
}

Meiner Meinung nach sollte es nur eine mögliche Situationen geben:
1. Workerthread besitzt das Lock, Hauptthread muss warten. (ev. bekommt der Hauptthread das Lock sofort, dann weiter bei 3.)
2. Workerthread gibt Lock frei, Hauptthread übernimmt. Workerthread muss warten.
3. Hauptthread setzt "die" auf true, gibt Lock frei, wartet auf Terminierung vom Workerthread. Workerthread terminiert. Hauptthread löscht Resourcen.

Meine Annahme scheint mir sehr logisch. Ist da vielleicht etwas mit der CCriticalSection nich i.O???

Bin für jeden Hinweis, oder Idee dankbar.
Grz daboss