genrerelles Model zur Parallelprogrammierung (mit C++)

Hallo Community,

Die Überschrift klingt etwas merkwürdig aber ich weiß nicht so ganz wie ich das Problem ausdrücken darf. Ich habe ein wenig Ahnung von C++ und herausgefunden, wie ich eine Funktion als seperaten Thread meiner Anwendung starten kann.

ganz grob das Beispiel:
Mein erster Versuch in diese Richtung hat (Bitmap-)Frames erzeugt, die ich dann im Nachhinein (mithilfe eines Tools) zu einem Film zusammenbasteln konnte.

Zum berechnen eines Frames war lediglich die Frame-ID nötig -> realisiert über einen globalen Integer, etwa so:

Code:

int Global = 0; // globale ID

DWORD WINAPI ThFnk() // Thread Funktion (läuft dann mehrfach)
{
    while(Global < 500)
    {
        int Lokal = Global;
        Global++;

        FrameErstellen(Lokal);
    }
}

... // Threads in main() mit CreateThread erzeugen 

hat soweit erstmal klasse funktioniert

Nun ist diese Aufgabe ja ziemlich simpel und die Threads haben keine (?) Möglichkeit sich irgendwie "zu verhaken".

Wenn ich jetzt aber mal drüber nachdenke, dann gibt es ja einen Part, den alle Threads nacheinander durchlaufen müssen, zwischen"int Lokal = Global;" und "Global++;" darf kein anderer Thread dazwischenfunken.

Ist das eine Sollbruchstelle und, wenn ja, gibt es ein Standardmodell, nach dem man diese Situation vermeidet?

 

es gibt einen "standard", wenn man aus threads auf gemeinsame daten zugreift. er heißt mutex.

 

Danke für die schnelle Antwort

 

Ein schönes (und auch ziemlich generelles) Mittel für sowas sind blockierende Warteschlange + n Produzenten + m Verbraucher.

Die Warteschlange wiederum durch Mutex geschützt und veranlasst außerdem Threads, die dort Daten rausholen wollen, zu warten bis auch wirklich Daten drin sind. (In Java: Interface BlockingQueue)

Damit kann man die Produzenten- bzw. Verbraucherthreads sehr schön hoch- und runterskalieren und alles passt trotzdem..

Man bräuchte Wahrscheinlich noch eine weitere Queue für die Ergebnisse (die oben hab ich mal auf zu verarbeitende Rohdaten bezogen) aber damit funktioniert's genauso.

Leider ist aber ab bestimmten n und m die Grenze erreicht, aber die Synchronisation aller Threads den Leistungsgewinn wieder aufrisst.

Das ganze kommt aber immer auf das spezielle Problem und natürlich die Anzahl verfügbarer CPU Kerne an.