Am Anfang werden zwei Threads erstellt. Es soll nun jeder der beiden Threads darauf warten bis der andere eine gewisse aktion ausgeführt hat, dass funktioniert über zwei bool Variablen die global definiert sind.

funktionsweise:

Thread_1 setzt _bool1 auf true und wartet danach bis _bool2 auf true ist.

while(run)
{
  _bool1 = true;
  i++;

  while(!_bool2)
  {

  }

  _bool2 = false;
}

Thread_2 wartet bis _bool1 auf true ist und schaltet dann _bool2 auf true und _bool1 auf false

while(run)
{
  while(!_bool1)
  {

  }

  i++;

  _bool1 = false;
  _bool2 = true;
}

Das Hauptprogramm bricht jetzt nach einer Sekunde das ganze wieder ab(run auf false) und jeder Thread gibt an wie oft er ausgeführt wurde(über die lokale Variable i)
Das Programm funktioniert auch recht gut nur irgendwie sehr langsam.
Nach einer Sekunde habe ich bei beiden nur 30-40 durchläufe!

Habe beide mal ohne das Warten laufen lassen:

while(run)
{
   i++;
}

und kommme dabei auf astronomische Zahlen. Kann es sien das es etwas mit dem Schreiben und Lesen auf die globalen Variablen zu tun hat, das das ganze so langsam wird.
Ich hab leider von der Thread Programmierung noch so gut wie keine Ahnung,

wäre also schön wenn mir einer helfen könnte.

Mal angenommen, der Thread_1 ist gerade dran. Dann rennt er solange in dieser Schleife

while(!_bool2)
  {

  }

bis endlich Thread_2 vom Betriebsystem aktiviert wird. Thread_2 setzt dann bool2 auf true und verfängt sich in der Schleife

while(!_bool1)
  {

  }

da Thread_2 vorher bool1 auf false gesetzt hat. Das geht solange, bis das Betriebsyystem meint, dass mal wieder wer anders dran ist; z.B. thread_1 usw.
D.h. mit Hilfe dieses Programms misst Du die Thread-Wechselzeiten des Betriebssystems - so 30-40 pro Sekunde kommt gut hin; würde ich sagen.

Das was Du dort tust, nennt man pollen. Sowas sollte man tunlichst vermeiden, da die CPU nur mit Warten beschäftigt wird.
Wenn Du mehr über Thread-Synchronisierung im besonderen und Thread-Programmierung im Allgemeinen erfahren möchtest, so schaue Dir mal http://www.boost.org/doc/html/threads.html an. Mit dieser Bibliothek geht Thread-Programmierung sehr einfach und weiterführende Links sind dort auch zu finden.

Gruß
Werner

programmierst du das unter Windows oder Linux? Das macht nämlich einen Unterschied. Aber erstmal zum wesentlichen. Du hast Glück, dass dein Programm überhaupt läuft, denn normalerweise sollten solche geteilten Variablen (die von beiden Threads genutzt werden) durch mutexes geschützt werden. Das hat nicht nur den Vorteil, dass Seg Faults abegefangen werden, sonder die Threads werden auch darüber informiert, dass die Variable von jemand anderem geändert wurde, und es nötig ist, sie erneut aus dem Speicher zu lesen, und sie nicht weiter aus dem Register zu lesen.
Dieses Problem hat bei mir schon zu _eigenartigen_ Ergebnissen geführt.

Gruß Mea

unter windows gibts dafuer die events (schau nach CreateEvent, SetEvent ...)
Da events selber schon synchronisationsobjecte sind, musst die nicht schuetzen (Mutex, oder CriticalSektion unter windows)
Auf events kann man auch sehr einfach "warten" (WaitforSingleObject, WaitForMultiObject)

unter linux und pthread kenn ich mich ned so aus ... aber es sollte da aehnliche mechanismen geben ....

Oder du abreitest Unix typisch mit prozessen, dann hasst die probleme mit dem Threads und dem schuetzen der daten nich ... dafuer musst aber die informationen ueber IPC von einem Prozess zum anderen expliziet schleussen ...

Themen sind dann im groben Signale, Pipes, Shared memory, sockets ....

Ciao ...