面试题：C语言实现Linux prefork模型进程间通信优化的常见策略

优化策略一：减少进程创建开销

原理：进程创建是一个开销较大的操作，涉及内存分配、资源初始化等操作。在prefork模型中，预先创建一定数量的子进程可以避免在请求到来时频繁创建进程的开销。
实现方式：在程序启动阶段，通过循环调用fork()函数创建固定数量的子进程。例如：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define CHILD_PROCESS_NUM 5

int main() {
    for (int i = 0; i < CHILD_PROCESS_NUM; i++) {
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork error");
            exit(EXIT_FAILURE);
        } else if (pid == 0) {
            // 子进程逻辑
            printf("Child process %d created.\n", getpid());
            while (1) {
                // 等待任务分配
            }
        }
    }
    // 父进程逻辑
    while (1) {
        // 管理子进程，分配任务等
    }
    return 0;
}

选择依据：适用于请求频繁且处理时间较短的场景，如高并发的网络服务器。因为预先创建进程可以快速响应请求，减少响应延迟。

优化策略二：高效的任务分配机制

原理：合理的任务分配方式能够均衡各个子进程的负载，避免部分子进程过于繁忙而部分闲置，从而提高整体系统性能。
实现方式：
- 简单轮询：父进程维护一个子进程索引，每次有任务时，按照顺序将任务分配给下一个子进程。例如：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>

#define CHILD_PROCESS_NUM 5
#define PORT 8888

int main() {
    pid_t pids[CHILD_PROCESS_NUM];
    int current_child = 0;

    // 创建子进程
    for (int i = 0; i < CHILD_PROCESS_NUM; i++) {
        pids[i] = fork();
        if (pids[i] < 0) {
            perror("fork error");
            exit(EXIT_FAILURE);
        } else if (pids[i] == 0) {
            // 子进程逻辑，处理任务
            int sockfd = socket(AF_INET, SOCK_STREAM, 0);
            if (sockfd < 0) {
                perror("socket error");
                exit(EXIT_FAILURE);
            }
            struct sockaddr_in servaddr;
            memset(&servaddr, 0, sizeof(servaddr));
            servaddr.sin_family = AF_INET;
            servaddr.sin_port = htons(PORT);
            servaddr.sin_addr.s_addr = INADDR_ANY;
            if (bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
                perror("bind error");
                close(sockfd);
                exit(EXIT_FAILURE);
            }
            if (listen(sockfd, 5) < 0) {
                perror("listen error");
                close(sockfd);
                exit(EXIT_FAILURE);
            }
            while (1) {
                int connfd = accept(sockfd, NULL, NULL);
                if (connfd < 0) {
                    perror("accept error");
                    continue;
                }
                char buffer[1024];
                int n = recv(connfd, buffer, sizeof(buffer), 0);
                if (n > 0) {
                    buffer[n] = '\0';
                    printf("Child %d received: %s\n", getpid(), buffer);
                }
                close(connfd);
            }
        }
    }

    // 父进程逻辑，分配任务
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd < 0) {
        perror("socket error");
        exit(EXIT_FAILURE);
    }
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(PORT);
    servaddr.sin_addr.s_addr = INADDR_ANY;
    if (bind(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0) {
        perror("bind error");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    if (listen(sockfd, 5) < 0) {
        perror("listen error");
        close(sockfd);
        exit(EXIT_FAILURE);
    }
    while (1) {
        int connfd = accept(sockfd, NULL, NULL);
        if (connfd < 0) {
            perror("accept error");
            continue;
        }
        // 轮询分配任务
        pid_t target_pid = pids[current_child];
        // 通过某种进程间通信方式（如socketpair）将任务发送给子进程
        current_child = (current_child + 1) % CHILD_PROCESS_NUM;
        close(connfd);
    }
    return 0;
}

- **基于负载的分配**：父进程实时监控各个子进程的负载情况（如通过共享内存记录已处理任务数量、CPU使用率等指标），将任务分配给负载最轻的子进程。实现起来较为复杂，需要更多的进程间通信机制来传递负载信息。

选择依据：简单轮询适用于任务处理时间相对均匀的场景，实现简单且能基本保证负载均衡。基于负载的分配适用于任务处理时间差异较大的场景，能更精准地均衡负载，但实现成本较高。

优化策略三：使用共享内存进行进程间通信

原理：共享内存是最快的进程间通信方式之一，它允许多个进程直接访问同一块物理内存区域，避免了数据在不同进程地址空间之间的拷贝，从而提高通信效率。
实现方式：
- 使用shmget()函数创建共享内存段，例如：int shmid = shmget(IPC_PRIVATE, sizeof(int), IPC_CREAT | 0666);
- 使用shmat()函数将共享内存段附加到进程地址空间：int *shared_data = (int *)shmat(shmid, NULL, 0);
- 不同进程通过操作共享内存中的数据进行通信。通信完成后，使用shmdt()函数分离共享内存段，shmctl()函数删除共享内存段。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#define SHM_SIZE 1024

int main() {
    // 创建共享内存段
    int shmid = shmget(IPC_PRIVATE, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid < 0) {
        perror("shmget error");
        exit(EXIT_FAILURE);
    }

    pid_t pid = fork();
    if (pid < 0) {
        perror("fork error");
        shmctl(shmid, IPC_RMID, NULL);
        exit(EXIT_FAILURE);
    } else if (pid == 0) {
        // 子进程
        char *shmaddr = (char *)shmat(shmid, NULL, 0);
        if (shmaddr == (void *)-1) {
            perror("shmat error");
            exit(EXIT_FAILURE);
        }
        sprintf(shmaddr, "Hello from child %d", getpid());
        if (shmdt(shmaddr) == -1) {
            perror("shmdt error");
            exit(EXIT_FAILURE);
        }
    } else {
        // 父进程
        wait(NULL);
        char *shmaddr = (char *)shmat(shmid, NULL, 0);
        if (shmaddr == (void *)-1) {
            perror("shmat error");
            exit(EXIT_FAILURE);
        }
        printf("Parent received: %s\n", shmaddr);
        if (shmdt(shmaddr) == -1) {
            perror("shmdt error");
            exit(EXIT_FAILURE);
        }
        if (shmctl(shmid, IPC_RMID, NULL) == -1) {
            perror("shmctl error");
            exit(EXIT_FAILURE);
        }
    }
    return 0;
}

选择依据：适用于大量数据需要在进程间频繁传递的场景，如数据库缓存、多媒体数据处理等。但共享内存需要额外的同步机制（如信号量）来保证数据一致性。

优化策略四：利用缓存机制

原理：对于一些重复处理的任务或数据，缓存其结果可以避免重复计算，从而提高系统性能。
实现方式：
- 在父进程或子进程中维护一个缓存数据结构（如哈希表）。例如，使用glib库中的GHashTable，在C语言中实现简单的缓存功能如下：

#include <stdio.h>
#include <stdlib.h>
#include <glib.h>

// 简单的缓存示例
int main() {
    GHashTable *cache = g_hash_table_new(g_str_hash, g_str_equal);
    const char *key = "test_key";
    const char *value = "test_value";

    // 插入缓存
    g_hash_table_insert(cache, (gpointer)key, (gpointer)value);

    // 从缓存获取数据
    const char *cached_value = (const char *)g_hash_table_lookup(cache, key);
    if (cached_value) {
        printf("Cached value: %s\n", cached_value);
    }

    g_hash_table_destroy(cache);
    return 0;
}

- 当有任务到来时，先检查缓存中是否有对应的结果，如果有则直接返回，否则进行处理并将结果存入缓存。

选择依据：适用于任务具有重复性且处理结果相对稳定的场景，如Web服务器缓存静态页面、数据库查询结果缓存等。但需要考虑缓存的更新策略，避免使用过期数据。

星途面试题库

面试题：C语言实现Linux prefork模型进程间通信优化的常见策略

知识考点

面试题答案

优化策略一：减少进程创建开销

优化策略二：高效的任务分配机制

优化策略三：使用共享内存进行进程间通信

优化策略四：利用缓存机制