Safely Count and Display the Number of Processes Created Using Mutex and Threads

In this article, we will delve into a C programming example that demonstrates how to count the number of processes created within a loop using the fork function, while ensuring the count is displayed only once. We'll provide the complete C code, explanations, and insights on the importance of mutex synchronization and thread management in this context.

Problem Statement

The goal is to count the number of processes created by the following loop:

for (int i  0; i 3; i  ) { fork }

Notably, each call to fork doubles the number of processes, which means with the given loop, the total number of processes (including the original) will be (2^3 8).

Solution Approach

To achieve this, we use a shared variable to keep track of the process count and a mutex to synchronize access to this variable. This ensures that the count is updated safely and that it is displayed only once. Here is a complete C program to illustrate this:

Code Implementation

#include stdio.h#include stdlib.h#include unistd.h#include sys/types.h#include sys/wait.h#include pthread.h#define NUM_FORKS 3int process_count  0;pthread_mutex_t mutex;void fork_processes(void *arg) {    for (int i  0; i  NUM_FORKS; i  ) {        pid_t pid  fork();        if (pid  0) {            perror(NULL);            exit(1);        } else if (pid  0) {            // Child process            pthread_mutex_lock(mutex);            process_count  ;            pthread_mutex_unlock(mutex);            exit(0); // Child process exits        }    }    // Wait for all child processes to finish    for (int i  0; i  NUM_FORKS; i  ) {        wait(NULL);    }}int main() {    pthread_t thread;    // Initialize the mutex    pthread_mutex_init(mutex, NULL);    // Create a thread to handle forking    pthread_create(thread, NULL, fork_processes, NULL);    // Wait for the thread to finish    pthread_join(thread, NULL);    // Display the count    printf(Total number of processes: %d
, process_count);    // Clean up the mutex    pthread_mutex_destroy(mutex);    return 0;}

Explanation of the Code

Mutex Initialization: A mutex pthread_mutex_t is initialized to ensure that the process count is updated safely across multiple processes. Forking Processes: The fork_processes function contains a loop that calls fork three times. Each time a child process is created, it increments the process_count inside a critical section protected by the mutex. Waiting for Children: After forking, the parent process waits for all child processes to finish using wait(NULL). Displaying the Count: Once all processes have finished, the total number of processes created is printed. Cleanup: The mutex is destroyed after it is no longer needed.

Important Notes

The fork function creates a new process. Each call to fork doubles the number of processes. The above code ensures that the process count is displayed only once by using a single thread to handle the forking and counting.

Output: When you run this program, the output will show the total number of processes created, which should be 8.

Key Concepts:

Understanding how to use mutexes to synchronize access to shared resources, the role of the fork function in creating processes, and the importance of cleaning up resources after use are crucial for managing concurrent processes efficiently.

This approach is essential for building reliable and efficient multi-threaded applications in C, making it a valuable skill for any professional working with process management and synchronization.