ViaThinkSoft CodeLib
This article is in:
CodeLib → Programming aids → C / C++
Möchte man in C++ eine Funktion parallel, erstellt man einen neuen Thread. Möchte man jetzt aber die Funktion wirklich nur als Detached-Prozedur verwenden, auf die keine Kontrolle mehr erhoben werden soll, so kann folgender Code verwendet werden:
Achtung! Der Thread erhält kein "Join"! Das heißt, es ist möglich, dass der Hautprogrammteil fertig ist und das Programm beendet, ohne dass alle Thread-Funktionen zuende gelaufen sind!
Ggf. sollte bei jeder Funktion auf Fehler überprüft werden (Rückgabewert ist dann ungleich 0).
Die Verwendung ohne Parameter sieht wie folgt aus:
Soll z.B. ein int-Wert an die Funktion übergeben werden, sieht es folgendermaßen aus:
Ein C-String kann wie folgt übergeben werden:
Sollen mehrere Werte übergeben werden, so kann auf ein Struct-Element zurückgegriffen werden. Das sähe dann so aus:
//********************************************************************************************
//
// async_function_call
//
// Startet eine funktion, ohne auf diese zu warten.
void async_function_call( void* (*start_routine)(void*), void* arg ) {
pthread_t mythread;
pthread_attr_t tattr;
pthread_attr_init(&tattr);
pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
pthread_create( &mythread, &tattr, start_routine, arg );
pthread_attr_destroy(&tattr);
}Achtung! Der Thread erhält kein "Join"! Das heißt, es ist möglich, dass der Hautprogrammteil fertig ist und das Programm beendet, ohne dass alle Thread-Funktionen zuende gelaufen sind!
Ggf. sollte bei jeder Funktion auf Fehler überprüft werden (Rückgabewert ist dann ungleich 0).
Die Verwendung ohne Parameter sieht wie folgt aus:
void* meine_funktion(void*) {
std::cout << "Hallo World!" << ::std::endl;
return 0;
}
int main(void) {
async_function_call(meine_funktion, NULL);
return 0;
}Soll z.B. ein int-Wert an die Funktion übergeben werden, sieht es folgendermaßen aus:
void* meine_funktion(void* data) {
int arg = (int)data;
std::cout << "Hallo World!" << ::std::endl;
std::cout << arg << ::std::endl;
return 0;
}
int main(void) {
int arg = 7;
async_function_call(meine_funktion, (void*)arg);
return 0;
}Ein C-String kann wie folgt übergeben werden:
void* meine_funktion(void* data) {
char *arg = (char*)data;
std::cout << "Hallo World!" << ::std::endl;
std::cout << arg << ::std::endl;
return 0;
}
int main(void) {
char *arg = "Ich bin ein Mitbringsel!";
async_function_call(meine_funktion, (void*)arg);
return 0;
}Sollen mehrere Werte übergeben werden, so kann auf ein Struct-Element zurückgegriffen werden. Das sähe dann so aus:
struct koordinate {
int x;
int y;
};
void* meine_funktion(void* data) {
struct koordinate* k = (struct koordinate*)data;
int x = k->x;
int y = k->y;
std::cout << "Hallo World!" << ::std::endl;
std::cout << x << ::std::endl;
std::cout << y << ::std::endl;
free(k);
return 0;
}
int main(void) {
#ifndef __cplusplus
struct koordinate *k = malloc(sizeof *k);
#else
struct koordinate *k = (struct koordinate*) malloc(sizeof *k);
#endif
k->x = 3;
k->y = 7;
async_function_call(meine_funktion, k);
return 0;
}Daniel Marschall
ViaThinkSoft Co-Founder
ViaThinkSoft Co-Founder