Cara menggunakan fungsi fork dalam Linux

Penggunaan fungsi fork dalam Linux

Dalam sistem pengendalian Linux, fungsi fork() ialah fungsi panggilan sistem yang sangat penting, digunakan untuk mencipta proses baharu. Ia digunakan secara meluas dalam sistem pengendalian seperti Unix dan Unix. Dalam artikel ini, kami akan memperkenalkan penggunaan fungsi garpu secara terperinci dan memberikan beberapa contoh kod khusus.

1. Gambaran keseluruhan fungsi fork

Prototaip fungsi fork adalah seperti berikut:

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

pid_t fork(void);

Fungsi fork akan mencipta proses baru, iaitu salinan proses yang memanggil fork. Selepas memanggil fork, dua proses yang sama akan dihasilkan, iaitu proses induk dan proses anak. Kedua-dua proses adalah bebas dalam ingatan dan mempunyai ruang alamat bebas.

Proses induk memanggil fork dan mengembalikan nombor bukan negatif, yang menunjukkan PID (ID proses) proses anak. Proses kanak-kanak memanggil garpu dan mengembalikan 0. Jika panggilan fork gagal, -1 dikembalikan, menunjukkan bahawa penciptaan proses anak gagal.

2. Penggunaan fungsi fork

Berikut ialah penggunaan umum fungsi 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;
}

Dalam contoh di atas, kami mencipta proses anak baharu melalui fungsi fork. Dalam proses kanak-kanak, kami mencetak "Hello daripada proses kanak-kanak!" dan PID proses semasa. Dalam proses induk, kami mencetak "Helo daripada proses induk!" bersama-sama dengan PID proses semasa dan PID proses anak.

Apabila kita menjalankan kod di atas, kita akan mendapat output berikut:

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

Anda boleh melihat bahawa apabila fungsi fork berjaya dipanggil, proses induk dan proses anak akan melaksanakan kod program seterusnya pada masa yang sama .

3. Nilai pulangan bagi fungsi garpu

Dalam contoh di atas, kami menggunakan nilai pulangan fungsi garpu untuk menentukan sama ada proses semasa ialah proses induk atau proses anak.

• Jika nilai pulangan negatif (-1), bermakna panggilan fork gagal.
• Jika nilai pulangan ialah 0, bermakna proses semasa adalah proses anak.
• Jika nilai pulangan lebih besar daripada 0, ini bermakna proses semasa ialah proses induk, dan nilai pulangan ialah PID proses anak.

4. Aplikasi praktikal fungsi garpu

Fungsi garpu mempunyai banyak senario aplikasi dalam pembangunan sebenar, seperti pelayan serentak berbilang proses, kumpulan proses, dll. Di bawah ialah contoh mudah yang menunjukkan cara menggunakan fungsi fork untuk melaksanakan pelayan serentak yang mudah.

#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;
}

Dalam contoh di atas, kami menggunakan fungsi fork untuk melaksanakan pelayan serentak berbilang proses. Apabila pelanggan menyambung, kami mencipta proses kanak-kanak untuk mengendalikan permintaan pelanggan. Proses induk terus mendengar sambungan daripada pelanggan lain. Dengan cara ini, kami boleh mengendalikan berbilang permintaan sambungan pelanggan pada masa yang sama dan meningkatkan prestasi serentak pelayan.

Ringkasan:

Dalam artikel ini, kami memperkenalkan penggunaan fungsi fork dalam Linux dan menyediakan beberapa contoh kod khusus. Fungsi fork ialah fungsi panggilan sistem yang sangat penting dalam sistem pengendalian Linux. Ia boleh mencipta proses baharu dan membolehkan pelaksanaan proses serentak. Dengan menggunakan fungsi garpu secara rasional, kami boleh melaksanakan beberapa aplikasi serentak yang kompleks dan meningkatkan prestasi sistem.

Atas ialah kandungan terperinci Cara menggunakan fungsi fork dalam Linux. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!