Comment utiliser la fonction fork sous Linux

Utilisation de la fonction fork sous Linux

Dans le système d'exploitation Linux, la fonction fork() est une fonction d'appel système très importante, utilisée pour créer un nouveau processus. Il est largement utilisé dans les systèmes d'exploitation Unix et de type Unix. Dans cet article, nous présenterons en détail l’utilisation de la fonction fork et fournirons quelques exemples de code spécifiques.

1. Présentation de la fonction fork

Le prototype de la fonction fork est le suivant :

#include <sys/types.h>
#include <unistd.h>

pid_t fork(void);

La fonction fork créera un nouveau processus, qui est une copie du processus qui appelle fork. Après avoir appelé fork, deux processus identiques seront générés, à savoir le processus parent et le processus enfant. Les deux processus sont indépendants en mémoire et disposent d’espaces d’adressage indépendants.

Le processus parent appelle fork et renvoie un nombre non négatif, indiquant le PID (ID de processus) du processus enfant. Le processus enfant appelle fork et renvoie 0. Si l'appel fork échoue, -1 est renvoyé, indiquant que la création du processus enfant a échoué.

2. Utilisation de la fonction fork

Ce qui suit est l'utilisation générale de la fonction fork :

#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main() {
    pid_t pid;

    pid = fork();

    if (pid < 0) {
        // fork调用失败
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("Hello from child process! PID=%d
", getpid());
    } else {
        // 父进程
        printf("Hello from parent process! PID=%d, Child PID=%d
", getpid(), pid);
    }

    return 0;
}

Dans l'exemple ci-dessus, nous avons créé un nouveau processus enfant via la fonction fork. Dans le processus enfant, nous imprimons "Bonjour du processus enfant !" et le PID du processus en cours. Dans le processus parent, nous imprimons « Bonjour du processus parent ! » ainsi que le PID du processus actuel et le PID du processus enfant.

Lorsque nous exécutons le code ci-dessus, nous obtiendrons le résultat suivant :

Hello from parent process! PID=1234, Child PID=1235
Hello from child process! PID=1235

Vous pouvez voir que lorsque la fonction fork est appelée avec succès, le processus parent et le processus enfant exécuteront le code suivant du programme en même temps. .

3. La valeur de retour de la fonction fork

Dans l'exemple ci-dessus, nous utilisons la valeur de retour de la fonction fork pour déterminer si le processus actuel est un processus parent ou un processus enfant.

• Si la valeur de retour est négative (-1), cela signifie que l'appel fork a échoué.
• Si la valeur de retour est 0, cela signifie que le processus actuel est un processus enfant.
• Si la valeur de retour est supérieure à 0, cela signifie que le processus actuel est le processus parent et que la valeur de retour est le PID du processus enfant.

4. Applications pratiques de la fonction fork

La fonction fork a de nombreux scénarios d'application en développement réel, tels que des serveurs simultanés multi-processus, des pools de processus, etc. Vous trouverez ci-dessous un exemple simple montrant comment utiliser la fonction fork pour implémenter un serveur simultané simple.

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>

#define PORT 8888
#define MAX_BUFFER_SIZE 1024

int main() {
    int server_fd, new_socket;
    struct sockaddr_in address;
    pid_t child_pid;

    // 创建socket
    server_fd = socket(AF_INET, SOCK_STREAM, 0);

    // 设置address
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = INADDR_ANY;
    address.sin_port = htons(PORT);

    // 绑定socket和address
    bind(server_fd, (struct sockaddr *)&address, sizeof(address));

    // 监听socket
    listen(server_fd, 5);

    while (1) {
        // 接受客户端连接
        new_socket = accept(server_fd, NULL, NULL);

        // 创建子进程来处理客户端请求
        child_pid = fork();

        if (child_pid < 0) {
            // fork调用失败
            perror("fork");
            return 1;
        } else if (child_pid == 0) {
            // 子进程
            char buffer[MAX_BUFFER_SIZE] = {0};
            read(new_socket, buffer, MAX_BUFFER_SIZE);
            printf("Received message: %s
", buffer);
            close(new_socket);
            return 0;
        } else {
            // 父进程
            // 关闭父进程不需要的socket
            close(new_socket);
        }
    }

    return 0;
}

Dans l'exemple ci-dessus, nous utilisons la fonction fork pour implémenter un serveur simultané multi-processus. Lorsqu'un client se connecte, nous créons un processus enfant pour gérer la demande du client. Le processus parent continue d'écouter les connexions des autres clients. De cette façon, nous pouvons gérer plusieurs demandes de connexion client en même temps et améliorer les performances simultanées du serveur.

Résumé :

Dans cet article, nous avons présenté l'utilisation de la fonction fork sous Linux et fourni quelques exemples de code spécifiques. La fonction fork est une fonction d'appel système très importante dans le système d'exploitation Linux. Elle peut créer un nouveau processus et rendre possible l'exécution simultanée du processus. En utilisant rationnellement la fonction fork, nous pouvons implémenter des applications simultanées complexes et améliorer les performances du système.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!