how to create two processes from a single Parent

Question

I know I'm going to need to use fork(), but this just creates a single child process. Do i simply call fork again from within the child process? Also, I need them to communicate through a signal or pipe, which is easier to implement and what do i need to know for doing that (functions, etc..)

Answer 1

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
int main()
{
    system ("clear");
    int i ;
    pid_t childa,childb,childa1,childa2,childb1,childb2;
    printf("\n \t \t I am the parent process with ID %d \n",getpid());
    childa=fork();
    if (childa == 0 )
    {
        printf("\nI am a child A with PID %d and my parent ID is %d\n",getpid(),getppid());
    }
    else
    {
        childb = fork();
        if (childb == 0)
        {
            printf("\nI am Child B with ID %d and my parent ID is %d\n",getpid(),getppid());
        }
        else
        {
            sleep(1);
        }
    }
}

Answer 2

Just a little contribution, if you want to create 2 childs from the same parent you could use this code below. In which one father create 2 child processes (lazy and active).

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

int main (){
  pid_t lazy_child;

  lazy_child = fork();

  if(lazy_child == 0){ // This is the lazy child process.
    printf("LAZY CHILD:%d\n", getpid());
  }
  else if(lazy_child > 0){ // This is the father process.
    pid_t active_child = fork();

    if(active_child == 0){ // This is the active child process.
      printf("ACTIVE CHILD:%d\n", getpid());
    }
    else if(active_child > 0){ // This is the father process.
      printf("FATHER:%d\n", getpid());
    }
    else{ // Fork doesnt work.
      printf("fork error\n");
      exit(1);
    }
  }
  else{ // Fork doesnt work.
    printf("fork error\n");
    exit(1);
  }
  return 0;
}

If you run this code, you should get a similar output:

$ ./a.out 
FATHER:14501
ACTIVE CHILD:14503
LAZY CHILD:14502

Answer 3

#include <stdio.h>
#include <unistd.h>

void main(){
  int pi_d ;
  int pid ;
  pi_d = fork();
  if(pi_d == 0){
    printf("Child Process B:\npid :%d\nppid:%d\n",getpid(),getppid());
  }
  if(pi_d > 0){
    pid = fork();
    if(pid > 0){
      printf("\nParent Process:\npid:%d\nppid :%d\n",getpid(),getppid());
    }
    else if(pid == 0){
      printf("Child Process A:\npid :%d\nppid:%d\n",getpid(),getppid());
    }
  }
}

output :

Parent Process:
pid:3648
ppid :2379
Child Process B:
pid :3649
ppid:3648
Child Process A:
pid :3650
ppid:3648

Answer 4

In this example

they are just sleeping for a few random sec. It also has all the pid, so we can send SIGNAL to communicate...

Most of the #includes are commented cause they were useless where I compiled.

#include <stdlib.h> // exit() ...
#include <stdio.h> // printf() ...

// Compile with -lrt -> cc file_name.c -lrt

//#include <fcntl.h>
//#include <sys/stat.h>
//#include <sys/types.h>
//#include <sys/wait.h> // may need this for wait()
//#include <time.h>

//#include <unistd.h> // and this one for fork()

// In the start function you can do whatever you want.
void start (const int azon) {
    // For children processes
    srand( time(NULL) );
    unsigned t = rand()%5; // printf("%d\n", t);
    sleep(t);
    printf("%d. process reached the end.\n", azon);
    exit(0);
}

int main() {
    const int N = 5;
    pid_t pids[N];

    int i;

    // The 'for' loop make 'N' process with 'fork()'.
    // The children processes will call the start function.
    // Since after fork() you will get 2 process. One Parent, and One Child
    // The returning value from fork() is saved in "pids" which is an
    // integer AND it is (<0) IF something went wrong.
    //             it is (>0) IF 'we are' in the Parent process,
    // because this number is the Child process' ID (pid).
    // and Last    it is (==0) IF 'we are' in the Child process.
    for (i = 0; i < N; i++) {
        pids[i] = fork();
        sleep(1);
        if (pids[i] == 0) start(i+1); // ... OR you can make a switch(..)
    }
    // This 'for' loop in the wait(NULL) statement ONLY move on when a
    // process ended, so it waits until 'N' proc ends.
    for (i = 0; i < N; i++)
        wait(NULL);

    printf("Partent process reached the end\n");

    return 0;
}

Answer 5

To create a second process, call fork() again - either within the parent or the child (but not both!). Which you choose depends on whether you want this process to be a child of the original parent or a child of the first child process (it is usual for it to be a child of the original parent).

Communicating through a pipe is much simpler and more reliable than using signals. pipe(), close(), read(), write() and select() are the key functions here.

---

For example, to have the parent create two child processes, you would do something like:

pid_t child_a, child_b;

child_a = fork();

if (child_a == 0) {
    /* Child A code */
} else {
    child_b = fork();

    if (child_b == 0) {
        /* Child B code */
    } else {
        /* Parent Code */
    }
}

Answer 6

You can put the fork in a loop and generate as many child processes as you need. I did that on a project recently.

for(nSon=0; nSon < nSonsAsked; nSon++) {
  Log_Print("Setup son #%.2u ", nSon+1);

  if((pid = fork()) == 0) {
    /* Do child stuff init, like connect the pipes, close shared handles */

    return iTMInChild(...);     /* A specific function of the child work */
  /* The life of the child should not go beyond that point, i.e. the loop is over 
     or else the child will spawn even more processes. */ 
  }
  else if(pid > 0) {
    /* Father process stuff. Here I initialise an array with the pid of the forked */
    /* processes, this way I can index with the number of processes.*/
    pid[nSon] = pid;
  }
  else
    return Err_Print(ERR_FORK_FAILED, "fork failed. errno=%d \"%s\"\n", errno, strerror(errno));
}

Log_Print() and Err_Print() are internal functions but quite obvious so I let them like they are.

There is one aspect with the variables that has to be explained. nSon and nSonAsked should be declared as globals not as stack variables. This way, their value persists in the forked process. This means that the nSon variable will have a different value in each of the children. This allows it to have a simpler numbering scheme than the ownpid() number.

To get it completely right, there are a lot of details to get right. You will have to set signal handlers in the father process to detect the death of a child, likewise the other way round (only possible on Linux, other Unix (at least Solaris) do not support parent death signals). You have to be aware that open file descriptors in the father process will be also open in the child after fork and it will be the same one. This opens a lot of concurrency problems if you're not aware of it (the solution is using dup() and close() in the right places).