Implementing Multiprocessing in C: Process Creation and Management

In modern operating systems, multiprocessing is a common technique that allows programs to execute multiple tasks simultaneously. The C language provides robust support for implementing multiprocessing, primarily through the <span>fork()</span> system call to create new processes. This article will detail how to implement multiprocessing in C, including basic process creation and management.

1. What is a Process?

In computer science, a process is an instance of a program that is currently running. Each process has its own address space, data stack, and other information used to track its execution state. The operating system manages these concurrently executing processes through scheduling algorithms.

2. Creating a New Process

In C, we can use the <span>fork()</span> function to create a new child process. When <span>fork()</span> is called, the currently running program is duplicated, and the newly created child process will be almost identical to the parent process, but they will have different PIDs (Process IDs).

2.1 Return Value of fork()

• If the <span>fork()</span> call is successful, it returns twice:

• In the parent process, it returns the child’s PID.
• In the child process, it returns 0.

• If it fails, it returns -1, and no new child process is created.

Example Code: Basic fork()

Here is a simple example demonstrating how to use <span>fork()</span> to create a new process:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main() {
    pid_t pid = fork(); // Create new process
    if (pid < 0) { // Error handling
        perror("Fork failed");
        exit(1);
    } else if (pid == 0) { // Child process
        printf("This is the child process with PID: %d\n", getpid());
    } else { // Parent process
        printf("This is the parent process with PID: %d and created child PID: %d\n", getpid(), pid);
    }
    return 0;
}

Output Explanation

When you run the above code, you may see output similar to the following:

This is the parent process with PID: [Parent PID] and created child PID: [Child PID]
This is the child process with PID: [Child PID]

Note that due to scheduling uncertainty, the order of output may vary.

3. Managing Multiple Child Processes

We can manage multiple child processes using structures like loops and arrays. For example, we can create N parallel workers, each executing a specific task.

Example Code: Creating Multiple Child Processes

Below is an example where we will create 5 parallel workers:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define NUM_PROCESSES 5
int main() {
    pid_t pids[NUM_PROCESSES];
    for (int i = 0; i < NUM_PROCESSES; i++) {
        pids[i] = fork(); // Create new process
        if (pids[i] < 0) {
            perror("Fork failed");
            exit(1);
        } else if (pids[i] == 0) { // Child process
            printf("Child Process %d, PID: %d\n", i + 1, getpid());
            sleep(2); // Simulate some work
            exit(0); // Exit after completing work
        }
    }
    for (int i = 0; i < NUM_PROCESSES; i++) {
        wait(NULL); // Wait for all children to finish
    }
    printf("All child processes have completed.\n");
    return 0;
}

Output Explanation

This program will display information about each child process in the terminal and print a message after all children have completed. This code demonstrates how to wait for all started children to finish to ensure resources are properly released.

Conclusion

This article introduced important concepts of multithreading in C, including how to use <span>fork()</span> to generate new processes and how to manage multiple processes. In practical applications, multithreading can significantly improve program performance, allowing for more efficient use of CPU and memory resources. However, when developing multithreaded applications, it is also important to pay attention to synchronization and resource sharing issues to avoid potential data races and deadlocks.

I hope this article helps you understand the basics of multithreading in C.