Understanding forks in C

I am having some trouble understanding the following simple C code:

int main(int argc, char *argv[]) {
    int n=0;
    fork();
    n++;
    printf("hello: %d\n", n);
}

My current understa开发者_如何学JAVAnding of a fork is that from that line of code on, it will split the rest of the code in 2, that will run in parallel until there is "no more code" to execute.

From that prism, the code after the fork would be:

a)

    n++;                       //sets n = 1
    printf("hello: %d\n", n);  //prints "hello: 1"

b)

    n++;                       //sets n = 2
    printf("hello: %d\n", n);  //prints "hello: 2"

What happens, though, is that both print

hello: 1

Why is that?

EDIT: Only now it ocurred to me that contrary to threads, processes don't share the same memory. Is that right? If yes, then that'd be the reason.

After fork() you have two processes, each with its own "n" variable.

fork() starts a new process, sharing no variables/memory locations. It is very similar to what happens if you execute ./yourprogram twice in a shell, assuming the first thing the program does is forking.

At fork() call's end, both the processes might be referring to the same copy of n. But at n++, each gets its own copy with n=0. At the end of n++; n becomes 1 in both the processes. The printf statement outputs this value.

Actually you spawn a new process of the same progarm. It is not the closure kind of thing. You could use pipes to exchange data between parent and child.

You did indeed answer your own question in your edit.

examine this code and everything should be clearer (see the man pages if you don't know what a certain function does):

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

int count = 1;

int main(int argc, char *argv[]) {

    // set the "startvalue" to create the random numbers
    srand(time(NULL));
    int pid;

    // as long as count is <= 50
    for (count; count<=50; count++) {

        // create new proccess if count == 9
        if (count==9) {
            pid = fork();
            // reset start value for generating the random numbers
            srand(time(NULL)+pid);
        }

        if (count<=25) {
            // sleep for 300 ms
            usleep(3*100000);
        } else {
            // create a random number between 1 and 5
            int r = ( rand() % 5 ) + 1;
            // sleep for r ms
            usleep(r*100000);
        }

        if (pid==0) {
            printf("Child:  count:%d    pid:%d\n", count, pid);
        } else if (pid>0) {
            printf("Father: count:%d    pid:%d\n", count, pid);
        }
    }


    return 0;
}

happy coding ;-)

The system call forks more than the execution thread: also forked is the data space. You have two n variables at that point.

There are a few interesting things that follow from all this:

• A program that fork()s must consider unwritten output buffers. They can be flushed before the fork, or cleared after the fork, or the program can _exit() instead of exit() to at least avoid automatic buffer flushing on exit.
• Fork is often implemented with copy-on-write in order to avoid unnecessarily duplicating a large data memory that won't be used in the child.
• Finally, an alternate call vfork() has been revived in most current Unix versions, after vanishing for a period of time following its introduction i 4.0BSD. Vfork() does not pretend to duplicate the data space, and so the implementation can be even faster than a copy-on-write fork(). (Its implementation in Linux may be due less to speed reasons than because a few programs actually depend on the vfork() semantics.)