Kann ich vielleicht die neu in den C++-Standard integrierten Threads für mein Projekt verwenden? Ich tippe mal folgendes Beispiel aus der iX ab und messe die Zeit der Ausführung, für einen Thread und für beide Threads, mit std::lock_guard und Zugriff auf gemeinsame Variable und ohne:
#include <iostream>
#include <thread>
#include <time.h>
int counter;
const int NCOUNTS = 10000000000;
std::mutex incrementMutex;
void increment(){
for (int i=0; i<NCOUNTS; i++){
std::lock_guard<std::mutex> lock(incrementMutex);
counter++;
std::cout << counter << std::endl;
}
}
void decrement(){
for (int i=0; i<NCOUNTS; i++){
std::lock_guard<std::mutex> lock(incrementMutex);
counter--;
std::cout << counter << std::endl;
}
}
main(){
time_t seconds = time (NULL);
std::thread a(increment);
std::thread b(decrement);
a.join();
b.join();
time_t seconds2 = time(NULL);
std::cout << std::endl << seconds2-seconds << std::endl;
}
Mein aktueller g++ kommt ja schon zum großen Teil mit den neuen C++11-Features zurecht, so dass ich mit g++ -std=c++0x -pthread thread.cpp -o thread das Programm kompilieren kann. Der ich noch nicht so viel mit dem gefürchteten Thema des gemeinsamen Zugriffs von Threads auf Ressourcen zu tun hatte, bin überrascht. Benutze ich std::lock_guard und lasse beide Threads gleichzeitig die Variable count manipulieren, hört die Ausführung mit diesem NCOUNTS nicht mehr in vertretbarer Zeit auf. Ohne gemeinsamen Variablenzugriff hingegen, dauert die Ausführung 4 Sekunden. Eine Zeitersparnis hat man also nur ohne Zugriff auf gemeinsame Ressourcen. Wenn ohne diesen Zugriff beide Threads so ideal wie hier das selbe tun, kann man dies wunderbar parallelisieren. Man sieht schön in der Systemüberwachung und anhand der Ausgabe der benötigten Zeitdauer, dass hier in gleicher Zeit das Doppelte getan wird. Aber wo kann man in der Realität eine Aufgabe in genau gleiche Teile teilen? Mal schauen, ob ich diese Verwendung noch in meiner Programmiererei unterbringen kann … Threads sind aber auch da sinnvoll, wo Multitasking ermöglicht werden soll. Android schreibt z.B. vor, dass länger dauernde Prozesse nicht im GUI-Thread laufen, sondern parallelisiert werden sollen. Wird die Ausführung der Oberfläche auch für einige Sekunden unterbrochen, sieht der Benutzer den gefürchteten ANR (Application not responding)-Dialog. Natürlich läuft eine Oberfläche flüssiger, wenn Hintergrundprozesse auch in einem eigenen Thread laufen.