Mehrere Threads auf eine PThread struktur

[Michael D. (Gast)]

Hallo zusammen,

wenn ich eine globale Variable

pthread_t stackworker;

habe und mit

pthread_create(&stackworker,NULL,&WorkerThread,this)

einen Thread (Thread 1) erzeuge, wird ein Thread erzeugt und 
abgearbeitet.

void * WorkerThread(void * arg) {

    // Process stack
    return NULL;
}

Wenn ich nun einen weiteren Thread (Thread 2) auf die 
Stackworkervariable erzeuge noch bevor Thread 1 beendet ist, so wird der 
Thread 2 erzeugt sobald Thread 1 endet.

Dies ist der Zustand den ich eigentlich möchte, nur:
Ist diese Methode auch so zulässig (evtl. Speicherlecks, etc...)??

Danke,
Michael

Background:
Ich habe Funktionen welche zwar sofort zurückkehren aber eine weitere 
Bearbeitung durch eine Messagequeue benötigen. Diese Queue bearbeite ich 
im Thread, welchen ich auch in der jeweiligen Funktion erzeuge. Die 
Queue im Thread wiederum kann eine Callbackfunktion aufrufen, welche 
wiederum eine Funktion aufruft welche einen Queue benötigt. D.h. Es wird 
ein neuer Queuethread in einem Queuethread erzeugt.
Die Threads sollen dabei nacheinander ablaufen.

void Foo1() {
 ...
 createThread();
}

void Foo2() {
 ...
 createThread();
}

void Thread() {
  ...
  Foo2(); // Thread wird nach Foo2 verlassen
}

[Michael D. (Gast)]

Hat sich erledigt. Es laufen kurzzeitig zwei Threads parallel, Valgrind 
meldet kein Speicherleck.

[Oliver R. (superberti)]

Hi Michael,

> Hat sich erledigt. Es laufen kurzzeitig zwei Threads parallel, Valgrind
> meldet kein Speicherleck.

Nee, so wird das nichts! Startest Du die Threads zu häufig, dann gehen 
dir die Ressourcen aus, denn

http://www.kernel.org/doc/man-pages/online/pages/man3/pthread_create.3.html

sagt:

A thread may either be joinable or detached.  If a thread is joinable, then
       another thread can call pthread_join(3) to wait for the thread to terminate
       and fetch its exit status.  Only when a terminated joinable thread has been
       joined are the last of its resources released back to the system.  When a
       detached thread terminates, its resources are automatically released back to
       the system: it is not possible to join with the thread in order to obtain its
       exit status.  Making a thread detached is useful for some types of daemon
       threads whose exit status the application does not need to care about.  By
       default, a new thread is created in a joinable state, unless attr was set to
       create the thread in a detached state (using pthread_attr_setdetachstate(3)).

Du musst also pthread_join aufrufen, um die Ressourcen des Threads 
freizugeben. Das geht aber nicht, da Du Dir den ersten pthread_t schon 
überschrieben hast...

Gruß,

Oliver

[Michael D. (xaero80c51) (Gast)]

Hallo Oliver,

vielen Dank für den Hinweis, da wäre ich darübergestolpert!

Ich werde versuchen den Thread nicht zu beenden sondern nur pausieren / 
anhalten.

Dürfte sowieso die bessere Methode sein.

Danke,
Michael