Applications of C Language in Operating Systems: Processes and Threads

In modern operating systems, processes and threads are two very important concepts. They are the foundation for achieving concurrent execution and improving program performance. In this article, we will delve into how the C language is used to create and manage processes and threads, demonstrating their basic usage through code examples.

1. Process

1.1 What is a Process?

A process is an instance of a program that is currently running on a computer. Each process has its own address space, data stack, and other auxiliary data to track its execution state. The operating system manages multiple processes through scheduling algorithms to achieve multitasking.

1.2 Creating a New Process

In C, you can use the <span>fork()</span> function to create a new child process. The <span>fork()</span> function duplicates the current parent process and returns twice: once in the parent process with the child’s PID and once in the child process with 0.

Example Code:

#include <stdio.h>
#include <unistd.h>
int main() {
    pid_t pid = fork(); // Create a new child process
    if (pid < 0) {        // fork failed
        perror("Fork failed");
        return -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 child PID: %d\n", getpid(), pid);
    }
    return 0;
}

1.3 Compilation and Execution

To compile the above code, you can use the following command:

gcc -o process_example process_example.c

Then run the generated executable:

./process_example

You will see output displaying information about the parent and child processes.

2. Thread

2.1 What is a Thread?

A thread is a lightweight execution unit compared to an independent program; it shares the same address space but has its own stack and registers. Multithreading can improve application performance, especially in I/O-bound or CPU-bound tasks.

2.2 Creating a New Thread

In C, you can use the <span>pthread</span> library from the POSIX standard library to create and manage threads. First, you need to include the header file <span><pthread.h></span>, and then you can use the <span>pthread_create()</span> function to create a new thread.

Example Code:

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
void* thread_function(void* arg) {
    int id = *((int*)arg);
    printf("Hello from thread %d!\n", id);
    return NULL;
}
int main() {
    pthread_t threads[5];
    for (int i = 0; i < 5; i++) {
        int* arg = malloc(sizeof(*arg)); // Dynamically allocate memory to pass arguments to thread function
        *arg = i;
        pthread_create(&threads[i], NULL, thread_function, arg); // Create new thread
    }
    for (int i = 0; i < 5; i++) {
        pthread_join(threads[i], NULL); // Wait for all threads to finish
    }
    return EXIT_SUCCESS;
}

2.3 Compilation and Execution

To compile the above code, you need to link the pthread library, you can use the following command:

gcc -o thread_example thread_example.c -lpthread

Then run the generated executable:

./thread_example

You will see output displaying greetings from each thread.

Conclusion

This article introduced how the C language is used for basic concepts in operating systems—processes and threads. We demonstrated how to create and manage these concurrent entities through simple examples. In actual development, choosing the appropriate method for concurrent processing based on specific needs will greatly enhance application performance and responsiveness. If you are interested in multitasking, you might further explore related topics such as synchronization mechanisms, mutexes, and more. These are all essential components for building efficient and reliable software.