4. Kinderprozesse erstellen mit fork()

Kinderprozesse erstellen mit fork()

  • T

    Guten Tag,

    ich habe eine Frage. Und zwar will ich in meinem Programm mit meinem Vaterprozess n Kinderprozesse erstellen, die in einer Endlosschleife eine Funktion aufrufen, nur leider weiß ich nicht genau wie ich das ganze machen soll.

    #include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <unistd.h>

#define numberOfProcesses 5

void bobo(int index);

int marketplace[20] = {0};

int main(void) {
    pid_t pid;

    srand(time(NULL));

    for (int i = 0; i < numberOfProcesses; i++) {
        if ((pid = fork) == -1) {
            perror("fork");
            exit(EXIT_FAILURE);
        }

        else if (pid == 0) {
            bobo(rand() % 20);
        }
    }

    return EXIT_SUCCESS;
}

    Komme ab hier nicht weiter, ich weiß nicht, ob ich hier nun die gewünschten 5 Prozesse hab, 1 Vater und 4 Kinder und wie die 4 Kinder nun die Funktion bobo ind einer Endlosschleife aufrufen sollen? Weil das soll ja nicht immer nur der gleiche Prozess machen.

    Bin für jede Hilfe dankbar.

    MfG

    0
  • ?

    So wie das im Augenblick ist, rufen die Kinder die Funktion bobo einmal auf.
    Dann geht die for-Schleife weiter und die Kinder machen auch noch mal ein fork (diesmal mit i = 1).
    Da sind sie aber Vater und es wird kein bobo mehr gemacht.
    Die for Schleife geht aber immer noch weiter bis i == numberOfProcesses. Jedesmal wird wieder ein Kind erzeugt.
    Da aber jedesmal das i höher ist, kommt es doch mal zum Ende.

    Was sollen die Kinder machen? Endlosschleife?

    else if (pid == 0) {
            while (1) {  // Endlosschleife
              bobo(rand() % 20);
            }
            break;  // for-Schleife beenden. Wird aber nie erreicht.
        }
    0
  • T

    Also der Vaterprozess soll die angegebene Nummer an Kinderprozessen erstellen, welche in einer Endlosschleife eine Funktion namens Bobo aufrufen. Ich komm einfach nicht weiter, habe keine Ahnung wie ich das realisieren kann.

    0
  • S

    Aha. Die Frage ist dir aber schon beantwortet worden, warum wiederholst Du sie?

    0
  • T

    Nein ist sie nicht, so ruft ja immer der selbe Kindsprozess die Funktion auf, sie sollen aber abwechselnd die Funktion aufrufen.

    0
  • ?

    tobias321 schrieb:

    Nein ist sie nicht, so ruft ja immer der selbe Kindsprozess die Funktion auf, sie sollen aber abwechselnd die Funktion aufrufen.

    Wie kommst du zu dieser Aussage? Wie stellst du das fest?

    Vater und Kind laufen nach dem fork an derselben Stelle weiter
    Alle Variablen sind gleich, nur der Rückgabewert von fork ist anders.

    Das Kind bekommt die 0 und kommt beim else if (pid == 0) in die Endlosschleife.

    Der Vater macht mit dem erzeugen der Kinder weiter, da für ihn die pid != 0 ist.

    0
  • T

    Mein Code sieht jetzt folgendermasen aus:

    // Create the Child processes
    for (int i = 0; i < numberOfProcesses; i++) {
        if ((pid = fork()) == -1) {
            perror("fork");
            exit(EXIT_FAILURE);
        }
        else if (pid == 0) {
            while (1) {
                printf("%d", getpid());
                bobo(rand % 20);
            }
            exit(EXIT_SUCCESS);
        }
        else {
            //signal(SIGUSR1, serverReadproducts);
            wait(NULL);
        }
    }

    Als Ausgabe erhalte ich immer die selber Prozess Id.
    Noch was anderes, weiß jemand warum ich hier immer den gleichen Zufallswert bekomme? Seed ist am Beginn der Main gesetzt.

    0
  • L

    Jetzt startest du einen Kindprozess, der in einer Endlosschleife die Funktion aufruft. (Argument müsste aber rand()%20 sein, oder? Wie setzt du den seed?)
    Der Vaterprozess wartet aber auf den Kindprozess.

    Willst du, dass die Kindprozesse wirklich abwechselnd die Funktion aufrufen oder einfach alle parallel?

    0
  • T

    parallel geht auch, ok der Vater soll nicht warten, sondern einfach sobald er das Signal SIGUSR1 bekommt in seine Funktion gehen, kann ich das wait(NULL) dann weglassen??

    Seed sieht so aus.

    srand(time(NULL));
    0
  • L

    tobias321 schrieb:

    kann ich das wait(NULL) dann weglassen??

    Wenn du nicht willst, dass er immer auf den gerade gestarteten Prozess wartet, musst du es sogar weglassen. Zumindest an der Stelle.

    srand wird also einmal im Vaterprozess aufgerufen. Das heißt aber auch, dass jedes Kind die selbe Folge an Pseudozufallszahlen erzeugt.

    Um auf dein Signal zu warten:

    sigset_t sset;
	sigemptyset(&sset);
	sigaddset(&sset, SIGUSR1);
	sigprocmask(SIG_BLOCK, &sset, NULL);
	int s;
	sigwait(&sset, &s);
    0
  • C

    Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C (C89, C99 und C11) in das Forum Linux/Unix verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.

    0
  • T

    Wie schaff ich es dann, dass jeder Kindprozess eine neue Zufallszahl bekommt?

    0
  • L

    Du kannst die Zahl vor dem fork "ziehen".
    Du kannst srand zB auch mit der pid + time verrechnen. (Für jedes Kind.)
    Wobei du immernoch doppelte Zahlen haben könntest.
    Wieso nimmst du nicht einfach (dem Paramternamen entsprechend) eine fortlaufende Zahl, wie das i aus der Schleife?

    0
  • T

    Weil die Zahl zufällig sein muss, die Zufallszahl ist nichts anderes wie der Index eines Arrays, und der muss zufällig ausgewählt werden. Vor dem fork ziehen geht auch nicht, da bekomm ich immer nur 2 Zahlen. Ich versuchs jetzt noch mit der pid + time.

    0
Anmelden zum Antworten