void* f(void p){            

   return 0;
 }
 main() {
   int i = 0;
   while ( i<=5 )
   {
     pthread_t t;
     pthread_create(&t, 0, f ,(void) i);
     i++;
   }
   pthread_exit(0);
 }

zu erledigen war nun folgendes
a) In welchen Zeilen Befinden sich Syntaxfehler und wie lauten die Zeilen richtig?
b) Unter der Annahme, dass alle Syntaxfehler beseitigt sind: aus wie vielen Threads besteht die Anwendung insgesamt?
c) Unter der Annahme das alle Sytaxfehler beseitigt sind: ergänze das Programm soe, dass an der Konsole von jedem Thread
genau eine Meldung erscheint. Die Meldung muss für jeden Thread unterschiedlich lauten

Fehler#1: Zeile 1 man braucht einen void* in der Klammer
#2: beim phthread_create gehöhrt

pthread_create(&t,0,f,(void *) i);

(also ebenfalls mit void*)

dann ich hätte vermutete dass es 6 threads sind, dürfte aber nicht stimmen

und wie macht man dass mit der ausgabe?

ich habs momentan auf das geändert

void* f(void *p){
  return 0;
}

 int main() {
    int i = 0;
    while ( i<=5 )
    {
      cout <<"Thread " << i << " wurde erzeugt"<<endl;
      pthread_t t;
      pthread_create(&t,0,f,(void *) i);
      i++;
    }
    pthread_exit(0);
 }

dürft aber auch net wirklich passen
ich vermute es gehöhrt noch etwas in void* f(void* p) rein, weil das ist ja nicht einfachso vorhanden....

bitte um rasche hilfreiche antwort

stefan

void *f (void *p)
{
  return (void*)0;
}

int main() 
{
    int i = 0;
    while (i <= 5)
    {
      pthread_t t;
      pthread_create (&t, (const pthread_attr_t*)0, f, (void*)i);
      cout << "Thread " << i << " wurde erzeugt" << endl;
      i++;
    }
 }

nur so dahinghackt, also ohne gewähr

extern "C" {
#include <pthread.h>
}
#include <iostream>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

extern "C" void * f(void * p)
{            
   int * ptr = static_cast<int *>(p);
   pthread_mutex_lock(&mutex);
   std::cout << "Meine Meldung: " << *ptr << std::endl;
   pthread_mutex_unlock(&mutex);
   return 0;
}

int main() {

   int * ptr[5];
   pthread_t t[5];

   for (int i = 0; i != 5; ++i) {
      ptr[i] = new int(i);
      pthread_create(&t[i], NULL, f, static_cast<void *>(ptr[i]));        
   }

   pthread_mutex_lock(&mutex);
   std::cout << "Mastermeldung" << std::endl;
   pthread_mutex_unlock(&mutex);

   for (int i = 0; i != 5; ++i) {
      pthread_join(t[i], NULL);
      delete ptr[i];
   }
}

das erste (von net) is doch fast das selbe wie meines oder?
nur dass ich nicht verstehe was es damit auch sich aht "(const pthread_attr_t*)"

zum 2ten
das ist mir für meinen momentanen wissenstand noch zu hoch, aber mit mutex mussten wir es noch nicht machen, da wir das da noch nicht gelernt hatten

danke jdenfalls

das erste (von net) is doch fast das selbe wie meines oder?
nur dass ich nicht verstehe was es damit auch sich aht "(const pthread_attr_t*)"

ja, ich hab nur ein paar typecasts reingesetzt. jag's doch mal durch nen compiler, dann siehste ja ob fehlermeldungen kommen. das von ponto sieht ja wohl ein bisschen extrem aus (ich nehme aber an, er hats ausprobiert und es kommen keine fehlermeldungen )

danke für die raschen antworten

das erste (von net) is doch fast das selbe wie meines oder?
nur dass ich nicht verstehe was es damit auch sich aht "(const pthread_attr_t*)"

zum 2ten
das ist mir für meinen momentanen wissenstand noch zu hoch, aber mit mutex mussten wir es noch nicht machen, da wir das da noch nicht gelernt hatten

danke jdenfalls

Hier nochmal der Code mit Kommentaren und ohne dynamische Allozierung:

extern "C" {
// Phtreads sind eine C Bibliothek und müssen deshalb mit extern "C" included
// werden, auch wenn in 95% der Fälle das innerhalb der phtread.h bereits
// getan wird.
#include <pthread.h>  
}

// Ausgabe mit std::cout
#include <iostream>

//Ein Mutex wird statisch initialisiert.
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

//Die Funktion, die pthread_create bekommt muss C Linkage haben. Deshalb muss
//diese Funktion extern "C" deklariert werden. Der Parameter und der Rückgabe
//wert müssen beide void * sein.
extern "C" void * f(void * p)
{            
   //Wir wissen, dass der Parameter ein int * ist und können den damit casten
   int * ptr = static_cast<int *>(p);

   //Es ist notwendig die Ausgabe der Meldung mit einem Mutex zu schützen, 
   //da die benutzung von std::cout nicht reentrant ist. Wenn zwei Threads
   //gleichzeitig schreiben, gibt das ein Chaos. Gleiches gilt für Ausgaben
   //via printf und co.
   pthread_mutex_lock(&mutex);
   std::cout << "Meine Meldung: " << *ptr << std::endl;
   pthread_mutex_unlock(&mutex);

   //Aus der mit pthread_create aufgerufenen Funktion zurückkehren heisst auch
   //den Thread beenden.
   return 0;
}

//main muss immer int zurückgeben
int main() {

   //jeder thread bekommt einen eigenen int Wert
   int arr[5];
   //Jeder Thread hat einen pthread_t. Diesen müssen wir uns merken,
   //damit wir die threads sauber aufräumen können
   pthread_t t[5];

   for (int i = 0; i != 5; ++i) {
      arr[i] = i;
      //Die fünf zusätzclihen Threads werden erzeugt, indem ein Zeiger auf den
      //Wert übergeben wird. Die pthread_t Id wird sich zum späteren Aufräumen
      //gesichert.
      pthread_create(&t[i], NULL, f, static_cast<void *>(&arr[i]));        
   }

   //Der Hauptthread muss sich natürlich auch den Ausgabekanal sichern.
   pthread_mutex_lock(&mutex);
   std::cout << "Mastermeldung" << std::endl;
   pthread_mutex_unlock(&mutex);

   for (int i = 0; i != 5; ++i) {
      //Nachdem die Threads sich beendet haben, können wir mit dem pthread_join
      //Aufruf dafür sorgen, dass sie sauber abgewickelt werden und keine
      //Leichen übrig bleiben.
      pthread_join(t[i], NULL);
   }
}

gn8