How to use the fork function in Linux

Usage of fork function in Linux

In the Linux operating system, the fork() function is a very important system call function, used to create a new process. It is widely used in Unix and Unix-like operating systems. In this article, we will introduce the usage of the fork function in detail and provide some specific code examples.

1. Overview of the fork function

The prototype of the fork function is as follows:

#include 
#include 

pid_t fork(void);

The fork function will create a new process, which is a copy of the process that calls fork. After calling fork, two identical processes will be generated, namely the parent process and the child process. The two processes are independent in memory and have independent address spaces.

The parent process calls fork and returns a non-negative number, indicating the PID (process ID) of the child process. The child process calls fork and returns 0. If the fork call fails, -1 is returned, indicating that the creation of the child process failed.

2. Usage of fork function

The following is the general usage of fork function:

#include 
#include 
#include 

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

In the above example, we created a new child process through the fork function. In the child process, we print out "Hello from child process!" and the PID of the current process. In the parent process, we print out "Hello from parent process!" along with the PID of the current process and the PID of the child process.

When we run the above code, we will get the following output:

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

It can be seen that when the fork function is called successfully, the parent process and the child process will execute the subsequent code of the program at the same time.

3. The return value of the fork function

In the above example, we use the return value of the fork function to determine whether the current process is a parent process or a child process.

• If the return value is a negative number (-1), it means that the fork call failed.
• If the return value is 0, it means that the current process is a child process.
• If the return value is greater than 0, it means that the current process is the parent process, and the return value is the PID of the child process.

4. Practical application of fork function

The fork function has many application scenarios in actual development, such as multi-process concurrent servers, process pools, etc. Below is a simple example showing how to use the fork function to implement a simple concurrent server.

#include 
#include 
#include 
#include 
#include 

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

In the above example, we use the fork function to implement a multi-process concurrent server. When a client connects, we create a child process to handle the client request. The parent process continues to listen for connections from other clients. In this way, we can handle multiple client connection requests at the same time and improve the concurrent performance of the server.

Summary:

In this article, we introduced the usage of the fork function in Linux and provided some specific code examples. The fork function is a very important system call function in the Linux operating system. It can create a new process and make the concurrent execution of the process possible. By rationally using the fork function, we can implement some complex concurrent applications and improve system performance.

The above is the detailed content of How to use the fork function in Linux. For more information, please follow other related articles on the PHP Chinese website!