fork()函数－创建子进程

fork():

The fork() system call will spawn a new child process which is an identical process to the parent except that has a new system process ID. The process is copied in memory from the parent and a new process structure is assigned by the kernel. The return value of the function is which discriminates the two threads of execution. A zero is returned by the fork function in the child's process.

The environment, resource limits, umask, controlling terminal, current working directory, root directory, signal masks and other process resources are also duplicated from the parent in the forked child process.

Example:

  1 #include<stdio.h>
  2 #include<unistd.h>
  3 #include<stdlib.h>
  4 int globalVariable = 2;
  5 int main(){
  6     char *sIdentifier;
  7     int iStackVariable = 20;
  8
  9     pid_t pID = fork();
 10
 11     if( pID == 0 ) {
 12         //Code only executed by child process
 13         sIdentifier = "Child Process: ";
 14         globalVariable++;
 15         iStackVariable++;
 16         } else if ( pID < 0 ) {
 17             printf( "Failed to fork!/n" );
 18             exit(1);
 19             //Throw exception
 20         } else {
 21             //Code only executed by parent process
 22             sIdentifier = "Parent Process: ";
 23         }  
 24
 25         //Code executed by both parent and child.
 26         printf( " %s/n", sIdentifier );
 27         printf( " Global variable: %d/n", globalVariable );
 28         printf( " Stack variable: %d/n", iStackVariable );
 29 }

 

explore@ubuntu:~/Documents/Linux C Programming/Process/fork$ gcc fork.c
explore@ubuntu:~/Documents/Linux C Programming/Process/fork$ ./a.out
 Parent Process:
 Global variable: 2
 Stack variable: 20
 Child Process:
 Global variable: 3
 Stack variable: 21

 

[Potential Pitfall] : Some memory duplicated by a forked process such as file pointers, will cause intermixed output from both processes. Use the wait() function so that the processes do not access the file at the same time or open unique file descriptors. Some like stdout or stderr will be shared unless synchronized using wait() or some other mechanism. The file close on exit is another gotcha. A terminating process will close files before exiting. File locks set by the parent process are not inherited by the child process.

[Potential Pitfall] : Race conditions can be created due to the unpredictability of when the kernel scheduler runs portions or time slices of the process. One can use wait() . the use of sleep() does not guarentee reliability of execution on a heavily loaded system as the scheduler behavior is not predictable by the application.

Note on exit() vs _exit() : The C library function exit() calls the kernel system call _exit() internally. The kernel system call _exit() will cause the kernel to close descriptors, free memory, and perform the kernel terminating process clean-up. The C library function exit() call will flush I/O buffers and perform aditional clean-up before calling _exit() internally. The function exit(status ) causes the executable to return "status" as the return code for main() . When exit(status ) is called by a child process, it allows the parent process to examine the terminating status of the child (if it terminates first). Without this call (or a call from main() to return() ) and specifying the status argument, the process will not return a value.

 

#include <stdlib.h> void exit(int status );

#include <unistd.h> void _exit(int status );

Man Pages:

• fork - create a child process