Wenn ich die Synchronisationsmechanismen von Windows benutze, schützen diese IMHO nur vor dem gleichzeitigen Zugriff mehrerer Threads oder Prozesse.

Ich habe aber nur einen Thread, der eine Funktion eines Objekts aufruft. Wenn dies geschieht, soll das Objekt vor einem nächsten Aufruf geschützt werden. Es wird von einer anderen Stelle wieder freigegeben.
Dann erst darf mein Thread wieder eine Funktion des Objekts aufrufen.

Gibts da unter Windows ne elegantere Möglichkeit, als das Objekt mit ner Boolschen Variable zu schützen?

Wenn dies geschieht, soll das Objekt vor einem nächsten Aufruf geschützt werden. Es wird von einer anderen Stelle wieder freigegeben.
Dann erst darf mein Thread wieder eine Funktion des Objekts aufrufen.

Und was ist das für eine "andere Stelle"? Liegt die auch in deinem Programm? Falls ja, wie soll der Schutz dann aussehen? Warten geht ja schlecht. Wenn dein einziger Thread wartet, wird diese "andere Stelle" ja nie erreicht.

Abstrakt gesehen kann man es so erklären:

CallbackFunktion(HardwareZugriff* hwz);

class HardwareZugriff
{
    Start();
    Stop();

    IrgendeinDatentyp Ergebnis;
}

Die Klasse HardwareZugriff kapselt eine Hardwarekomponente, die ich über einen Treiber anspreche. Davon hab ich mehrere Objekte im System. Wenn ich ein Ergebnis von der Hardware haben will kommt ein Thread, ruft die Start() auf - alle wichtigen Sachen werden initialisiert und der Treiber angeworfen.
Die Methode kehrt dann zurück und der Thread versucht den nächsten Zyklus.
Wenn ich ein Ergebnis der Hardware bekomme, benachrichtigt meine Treiber mich über die Callbackfunktion - diese ruft dann Stop() auf um aufzuräumen.
Nun muss ich sicherstellen, dass mein AufruferThread erst wieder Start() aufrufen kann, wenn meine CallbackFunktion Stop() für das Objekt aufgerufen hat.

Das könnte man halt über ne Boolsche Variable machen, aber ich finde es erstens unschön und außerdem muss man dann pollen.

Hoffe, man kann die Erklärung verstehen.