Thread-Programmierung (pthreads)

hallo,

ich experementiere mit threads und Nebenläufigkeit herum und bin dabei nicht so erfolgreich.

Was ich machen will:
Mein main-thread soll einen threadA aufwecken, wenn es etwas zu tun gibt, seine sache machen und sich dann wieder schlafen legen.

Ich habe deshalb versucht, erstmal nur den meachnismus mit dem aufwecken und schlafen legen umzusetzen. Das resultiert aber immer in einem deadlock innerhalb des threads.

hier meine code-schnipsel:

main-thread

FILE * f = fopen("/tmp/out.txt", "w");
  fwrite("Prüfe read_mutex\n", 1, sizeof("Prüfe read_mutex")+1, f);fflush(f);
  if ((r=pthread_mutex_trylock(&read_mutex)) != 0)
  {
       fwrite("trylock 1 fehlgeschlagen->gesperrt\n", 1, sizeof("trylock fehlgeschlagen->gesperrt")+1, f);fflush(f);
  }
  else
    fwrite("trylock: Lock ist moeglich\n", 1, sizeof("trylock: Lock ist moeglich")+1, f);fflush(f);

  //Aufwecken
  fwrite("Sende Signal\n", 1, sizeof("Sende Signal")+1, f);fflush(f);
  if (pthread_cond_signal(&read_cond)!= 0)
  {
       fwrite("Signal senden hat Fehler verursacht\n", 1, sizeof("Signal senden hat Fehler verursacht")+1, f);
       fflush(f);
  }
  else
    {fwrite("Signal gesendet\n", 1, sizeof("Signal gesendet")+1, f);fflush(f);}

  fclose(f);

threadA

void read_thread_function(void *ptr)
{
   FILE * f = fopen("/tmp/exp.txt", "w");

  fwrite("read_thread_function START\n", 1, sizeof("read_thread_function START")+1, f); fflush(f);

   while(1)
   {
     fwrite("read_thread_function LOOP\n", 1, sizeof("read_thread_function LOOP")+1, f); fflush(f);
     fwrite("read_mutex lock anfordern\n", 1, sizeof("read_mutex lock anfordern")+1, f); fflush(f);
     pthread_mutex_lock(&read_mutex);
     fwrite("read_mutex lock erhalten\n", 1, sizeof("read_mutex lock erhalten")+1, f); fflush(f);
     long r=0;
     //Warten auf Signal
     if ((r=pthread_cond_wait(&read_cond, &read_mutex)) != 0)
     {
 	if (r==EINVAL)
	{fwrite("invalid mutex or cond\n", 1, sizeof("invalid mutex or cond")+1, f);fflush(f);}

	if (r==ETIMEDOUT)
	{fwrite("Time out\n", 1, sizeof("Time out")+1, f);fflush(f);}

     }
     fwrite("read_thread_function CONDITION erfüllt\n", 1, sizeof("read_thread_function CONDITION erfüllt")+1, f); fflush(f);

     pthread_mutex_unlock(&read_mutex);     
     fwrite ("read_mutex unlocked\n", 1, sizeof("read_mutex unlocked")+1, f); fflush(f);
   }

  //fwrite("read_thread_function ENDE\n", 1, sizeof("read_thread_function ENDE")+1, f); fflush(f);
  //fclose(f);
}

Mein threadA kommt bis zur Funktion "pthread_cond_wait" und wacht dann nicht mehr auf. Das Signal wird aber wohl gesendet. Ich verstehe nicht ganz, was ich falsch mache. Ich hab auch schon probiert statt "pthread_cond_signal" die "pthread_cond_broadcast" zu nehmen, aber keine Veränderung.

Kann mir wer sagen was ich falsch mache, bzw. was zu tun ist, um threadA korrekt aufzuwecken?

XBert

Wahrscheindlich leigt es daran, dass das signal gesendet wird bevor der ThreadA darauf wartet.

LG