了解Unix中的fork机制

Question

I am trying to figure out the behaviour of parent and child process. Below is my code

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int main(void)
{
    int i,j,cnt=0;
    int pid,present_pid;
    int a[10];
    for(i=0; i<10; i++) {
        a[i] = i;
    }

    i = 0;
    j = 5;
    present_pid = getpid();
    printf("Now in process %d\n",getpid());
    printf("\n*******************before fork******************\n");
    for(i=0;i<10;i++) {
        printf("  %d",a[i]);
    }
    printf("\n*******************before fork******************\n");

    int ret = fork();
    if(ret == 0) {
        printf("\n*******************after fork******************\n");
        printf("Now in process %d\n",getpid());
        printf("Child Process created");
        for(i=0; i<5; i++) {
            a[i]= +1;
            i++;
        }
    }
    else if(ret > 0) {
        printf("\nNow in process %d\n",getpid());
        for(j=5; j<10; j++) {
            a[j] = +1;
            j++;
        }
        wait();
    }

    for(i=0;i<10;i++) {
        printf("  %d",a[i]);
    }
    return 0;
}

This is the output of the program

Now in process 12248

*******************before fork******************
  0  1  2  3  4  5  6  7  8  9
*******************before fork******************

*******************after fork******************
Now in process 12249
Child Process created  1  1  3  3  5  5  6  7  8  9
Now in process 12248
  0  1  2  3  4  6  6  8  8 

So Initially there is only one process 12248 which forks another process (12249). Now both the process run parallel (please correct me if I am wrong). Ideally child should add 1 to the contents of array a only to the first half and parent should do the same of the second part. But as you can see the output is not as expected. Please give suggestions..

Answer 1

A process created by fork is a real heavyweight OS process, not only a lightweight thread! The created process does not share any memory with the process from which it was forked. Instead, the memory is copied (lazily, so-called copy-on-write), so you actually have two arrays a now and each process writes to his own copy of a .

Answer 2

there are 2 small mistake in your code. Usually we don't even notice their existence.

1. a[i]= +1; oh, dear. I guess you want to write a[i] += 1 or a[i]++ .
2. Redundant i++ and j++ . The for loop has done this for you.

Correct them, and you'll get your expected answer.

Answer 3

First of all make some changes to your code

 printf("Now in process %d\n",getpid());
        printf("Child Process created");
        for(i=0; i<5; i++)
         {
   -->         a[i]+= 1;
    -->     //   i++; //comment this line you are jumping 2 steps in this loop
         }

As for the concept of fork()

Whenever you do a fork() call the exact copy of the process address space is created for child process and the program counter is set to the line after the fork() call

In your case after this line

     int ret = fork();
Program Counter-->    if(ret == 0)
                           {

next,

Now both the process run parallel

Yes the parent process does run in parallel but it waits for SIGCHLD signal from child process after its execution is finished.

If the child process returns the SIGCHLD signal but the parent process didn't recieve it yet(ie the parent process is in wait state) then the child process is called ZOMBIE process.

IF the parent process aborts abruptly and the child process is still running(or in READY state) the child process is called ORPHAN process. In this case the process called init is responsible for collecting the status of child process.

finally, the program flow. The parent process runs initially.

int ret = fork();//A child process is created

then this code executes in the child process

        if(ret == 0)
      {
        printf("\n*******************after fork******************\n");
        printf("Now in process %d\n",getpid());
        printf("Child Process created");
        for(i=0; i<5; i++)
         {
            a[i] += 1;
            //i++;
         }
      }
       else if(ret > 0)//this condition is false in child process
      {
          // rest of code
      }

//and finally this is exceuted

for(i=0;i<10;i++)
  {
    printf("  %d",a[i]);
  }
return 0;
    then child process returns SIGCHLD signal

the following code is executed in parent process

        else if(ret > 0)//this is true for parent process
      {
        printf("\nNow in process %d\n",getpid());
        for(j=5; j<10; j++)
          {
            a[j] = +1;
            j++;
          }
        wait();
      }

    for(i=0;i<10;i++)
      {
        printf("  %d",a[i]);
      }
    return 0;

}

NOTE: The parent process also returns the SIGCHLD signal and this signal is collected by init process

Whenever a new process is spawn it is by default child process of init process