pthreads: Conditional Variables

Fabeltier

Hallo,

ich habe mit conditional variables unter pthreads herumexperimentiert diese Woche, nun habe ich ein paar Fragen dazu und folgendes Demo geschrieben (laueft!).

1. Wann benutze ich PTHREAD_PROCESS_SHARED und wann PTHREAD_PROCESS_PRIVATE, so wie ich das verstanden habe wird SHARED benutzt, bei globalen Variablen und PRIVATE bei localen - stimmt das?

2. Wenn ich den "suspended thread" per conditional variable aufwecke, muss ich das pthread_cond_signal() bzw pthread_cond_broadcast() eigentlich auch, wie hier im Beispiel, mit einem Mutex sichern, oder ruft man da einfach nur "pthread_cond_signal()" auf?

pthread_mutex_lock(&mx_suspend);
  pthread_cond_signal(&cv_suspend);
  pthread_mutex_unlock(&mx_suspend);

3. Ich habe grosse Verstaendnis Schwierigkeiten in wie weit ich Mutexe und Conditionalvariablen, bzw deren Attribute aufraeumen muss oder ein Speicherleck bekomme. Haengt dies damit zusammen ob der Thread joinable/detached ist und wird bei detached Thread samt diesem Kram automatisch erledigt oder muss ich das immer selber zerstoeren?
Im unteren Demo zerstoere ich den Mutex und die Conditional Variable sowie deren Attribute selber.

pthread_cond_destroy(&cv_suspend);
  pthread_mutex_destroy(&mx_suspend);
  pthread_mutexattr_destroy(&attr_mx_suspend);
  pthread_condattr_destroy(&attr_cv_suspend);

4. Was mache ich bei dem Demo unten sonst noch falsch, bzw kann man das so implementieren?

Demo:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <unistd.h>
#include <pthread.h>

pthread_cond_t cv_suspend;
pthread_mutex_t mx_suspend;

pthread_t thr_sleepy;
void* thread_sleepy(void*);

int main()
{
  pthread_condattr_t attr_cv_suspend; // here: local variable
  pthread_condattr_init(&attr_cv_suspend);
  pthread_condattr_setpshared(&attr_cv_suspend, PTHREAD_PROCESS_SHARED); 
  pthread_cond_init(&cv_suspend, &attr_cv_suspend);

  pthread_mutexattr_t attr_mx_suspend; // here: local variable
  pthread_mutexattr_init(&attr_mx_suspend);
  pthread_mutexattr_setpshared(&attr_mx_suspend, PTHREAD_PROCESS_SHARED);
  pthread_mutex_init(&mx_suspend, &attr_mx_suspend);

  /******* thread **********/

  if(0 != pthread_create(&thr_sleepy, NULL, thread_sleepy, NULL)){
    perror("MAIN: pthread_create failed");
    exit(EXIT_FAILURE);
  } // check gegen 0 ok?
  puts("MAIN: thread created!");

  // some action..
  sleep(1);

  // awake thread
  puts("MAIN: resuming the suspended thread");
  pthread_mutex_lock(&mx_suspend);
  pthread_cond_signal(&cv_suspend);
  pthread_mutex_unlock(&mx_suspend);

  // wait to let thread catch up
  sleep(1); 

  // destroy the conditional variable stuff
  puts("MAIN: cleaning up conditional variable stuff");
  pthread_cond_destroy(&cv_suspend);
  pthread_mutex_destroy(&mx_suspend);
  pthread_mutexattr_destroy(&attr_mx_suspend);
  pthread_condattr_destroy(&attr_cv_suspend);

  puts("READY.");
  exit(EXIT_SUCCESS);
}

void* thread_sleepy(void* arg)
{
  puts("THREAD: dummy thread");
  puts("THREAD: suspends...");

  // suspends
  pthread_mutex_lock(&mx_suspend);
  pthread_cond_wait(&cv_suspend, &mx_suspend);
  pthread_mutex_unlock(&mx_suspend);

  puts("THREAD: ...awakes");
  puts("THREAD: exits");
  pthread_exit(0);
}

Danke im voraus.