When working with C programming language, the fork() system call is commonly used to create a new process. It allows the creation of child processes, which are identical to the parent process, except for the return value of the fork() call.
In this tutorial, we will focus on how to create two child processes using the fork() function. This can be useful in various scenarios, such as parallel programming or when you need to create multiple instances of a process.
To create two child processes, we will first call the fork() function once, which creates the first child process. Then, inside the child process, we will call fork() again to create the second child process. This way, we will end up with a total of two child processes.
It is important to note that each child process created by calling fork() will have its own copy of the parent’s code, data, and heap. However, they will share the same file descriptors, such as stdin, stdout, and stderr. This means that any changes made to these file descriptors in one child process will be visible to the other child process and the parent process as well.
Overview:
In C programming, the fork() system call is used to create a new process, which is called the child process, from an existing process, which is called the parent process. This allows you to have multiple processes running concurrently.
The fork() system call creates a new child process by duplicating the existing parent process. The child process has a unique process ID (PID) and starts executing from the point where the fork() system call was made.
After the fork() system call, both the parent and the child process will be executing the same code. However, they can be distinguished based on the return value of the fork() system call. If the return value is negative, the fork failed and no child process was created. If the return value is 0, it means that the process in which the fork() system call was made is the child process. If the return value is positive, it is the process ID of the child process in the parent process.
To create two child processes, you can use the fork() system call twice. The first fork() system call will create one child process, and the second fork() system call will create another child process. This will result in a total of three processes – the original parent process and the two child processes.
Step 1: Include the necessary libraries
In order to create two child processes using fork in C, you need to include the necessary libraries in your program. The fork() function is defined in the unistd.h library, so you should include it at the beginning of your code.
You can include the required library using the following line of code:
#include <unistd.h>
Including this library will give you access to the fork() function, which allows you to create child processes in your program.
Step 2: Fork a child process
In order to create two child processes, we will use the fork() system call in C. The fork() system call creates a new process by duplicating the existing process. The new process is called the child process, while the existing process is called the parent process.
Here is an example code snippet that shows how to use fork() to create two child processes:
int main(){ int pid1, pid2; pid1 = fork(); if (pid1 == 0) { printf("Child process 1 exit(0); } pid2 = fork(); if (pid2 == 0) { printf("Child process 2 exit(0); } printf("Parent process return 0;}
|
In this example, the fork() system call is used twice to create two child processes. After the first fork() call, the child process 1 is created, and after the second fork() call, the child process 2 is created. The parent process continues executing after each fork() call.
Inside each child process block, we can add code to perform specific tasks for each child process. In this example, the child process 1 prints “Child process 1” and exits, while the child process 2 prints “Child process 2” and exits. The parent process prints “Parent process”.
By using the fork() system call, we can create multiple child processes from a single parent process and perform parallel execution of code.
Step 3: Execute code for parent and child processes separately
Once the fork system call is executed successfully, the parent and child processes are created. Now, it is important to write separate code for each process in order to perform different tasks or actions.
For the parent process:
In the parent process, you can write code to perform certain actions or tasks that are specific to the parent. This can include operations like reading input, processing data, or executing specific functions. The code in the parent process will be executed immediately after the fork statement.
For example:
if (pid > 0) {
// This code will be executed by the parent process
printf("Parent process is executing.
");
// Perform additional actions specific to the parent
}
For the child process:
In the child process, you can write code to perform different actions or tasks that are specific to the child. This can include operations like writing output, performing calculations, or executing different functions. The code in the child process will also be executed immediately after the fork statement.
For example:
if (pid == 0) {
// This code will be executed by the child process
printf("Child process is executing.
");
// Perform additional actions specific to the child
}
By writing separate code for the parent and child processes, you can ensure that each process performs its intended tasks independently and without interfering with each other.
Step 4: Terminate the child processes
Once the child processes have completed their tasks, it is important to terminate them properly to avoid any lingering processes. To terminate a child process in C, you can use the exit() function. The exit() function takes an integer value as its argument, which represents the exit status of the process.
Here’s how you can terminate the child processes created using the fork() function:
| Child Process | Parent Process |
|---|---|
exit(0); |
Wait for child process |
In the child process, you can simply call the exit(0); function to terminate the process. The argument 0 indicates a successful termination. If the child process needs to indicate an error, you can pass a non-zero value as the argument.
In the parent process, you can use the wait() function to wait for the child process to terminate. The wait() function suspends the execution of the parent process until any of its child processes terminate. Once the child process terminates, the parent process resumes execution.
Here’s an example code snippet that demonstrates how to terminate the child processes:
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
int main() {
pid_t pid1, pid2;
pid1 = fork();
if (pid1 == 0) {
// Child process 1
printf("Child process 1
");
// Perform some tasks
exit(0);
} else if (pid1 > 0) {
pid2 = fork();
if (pid2 == 0) {
// Child process 2
printf("Child process 2
");
// Perform some tasks
exit(0);
} else if (pid2 > 0) {
// Parent process
int status;
wait(&status);
wait(&status);
printf("Parent process
");
// Perform some tasks
} else {
// Error occurred while forking
perror("Error occurred while forking");
exit(1);
}
} else {
// Error occurred while forking
perror("Error occurred while forking");
exit(1);
}
return 0;
}In this example, the parent process waits for both child processes to terminate using the wait() function. Once both child processes have terminated, the parent process resumes its execution and performs any remaining tasks.
