ich habe ein sehr merkwürdiges Problem: Ich habe ein Programm in MFC/Visual C++ geschrieben, dass zwei Threads erzeugt. Wenn ich das Programm im Debug-Modus starte, läuft es einwandfrei. Im Release Modus jedoch springt es aus dem einen Thread eher heraus als es soll! Warum?
Mein Programm im Detail:
Über einen Button wird mit dem Aufruf
> AfxBeginThread(Thread1, NULL, THREAD_PRIORITY_NORMAL, 0, 0, NULL); <
der Thread1 gestartet. In diesem Thread wird eine Liste erzeugt mit 10 Listenelementen, wobei eine Verzögerung von 2 Sek. (Sleep(2000)) zwischen dem Anfügen der jeweiligen Listenelemente eingebaut ist.
Über einen zweiten Button wird mit dem Aufruf
> AfxBeginThread(Thread2, NULL, THREAD_PRIORITY_NORMAL, 0, 0, NULL); <
der zweite Thread gestartet. Hier wird auf die in Thread1 zu erstellende Liste zugegriffen und die Listenelemente über den LPT versendet.
Das Problem tritt auf, wenn:
Drücke ich den ersten Button, so wird Thread1 (Erstellen der Liste) gestartet. Warte ich bis die Liste vollständig erstellt wurde (alle 10 Listenelemente) und drücke dann den Button2 (starten von Thread2), so tut Thread2 genau das was ich erwarte: er versendet die 10 Listenelemente über den LPT.
Drücke ich aber den Button2 (starten von Thread2) während noch die Listenelemente in Thread1 erstellt werden, so werden in Thread2 nur die Listenelemente über den LPT versendet, die zum Zeitpunkt des Drückens des Button2 in der Liste stehen. Die noch anzuhängenden Listenelemente werden nicht berücksichtigt, OBWOHL in Thread2 solange gewartet werden soll, bis alle Listenelemente da sind.
Dieses Problem tritt komischerweise aber nur im Release-Modus auf, im Debug-Modus wird im Thread2 solange gewartet bis alle Listenelemente da sind.
Warum macht es der Debug-Modus, aber nicht der Release-Modus?
Es wäre echt nett, wenn mir jemand helfen könnte. Bin da so ziemlich ratlos, ehrlich gesagt.
Danke,
Grüße
JohnTK

hier ein bsp wie du so was thread-sicher hinbekommst:

class Foo
{
  volatile int m_iItemCount; // da steht drinnen wieviele items in deiner liste sind
  HANDLE	m_hNewDataEvent; // event damit thread 2 mitbekommt wann neue daten da sind

  Foo() {
    m_iItemCount = 0;
    m_hNewDataEvent = CreateEvent(NULL,FALSE,FALES,NULL);
  }

   void Thread1()  // dein thread 1
   {
     put_data_into_list(); // stecke was neues in die liste
     InterlockedIncrement(&m_iItemCount); // zähle dein counter hoch
     SetEvent(m_hNewDataEvent); // sage thread 2: "was neues ist da"
   }

   void Thread2() // dein thread 2
   {
      while(...)
      { 
         // da die CPU wichtigeres zu tun hat als ein variable in ner 
         // schleife zu checken, machen wir erst was sobald auch daten da sind
         if(WaitForSingleObject(m_hNewDataEvent,INFINITE)==WAIT_OBJECT_0)
         {
           while(m_iItemCount>0) // solange noch was in der liste steht
           {
             send_data_to_LPT_port(); // schicke es zum LPT port raus
             InterlockedDecrement(m_iItemCount); // decrementiere den zähler
           }
         }
      }
   }
};

Allerdings hab ich keine Thread-Synchronisation über Sleep gemacht, das Sleep war nur dazu da, bei der Erzeugung von Listenelementen 2 Sekunden zu warten, bevor neues Listenelement erstellt wird. Kann somit gucken, ob der zweite Thread auf alle Elemente wartet.
Das Einbauen des Events hat die Lösung zu meinem Problem gebracht. Danke nochmals.
Gruß
JohnTK