MST

星途 面试题库

面试题：C语言优化HTTP服务器性能

假设你正在使用C语言开发一个高性能的HTTP服务器，在处理大量并发请求时，性能成为关键问题。请阐述你会从哪些方面进行优化，例如内存管理、线程/进程模型、I/O多路复用等，并详细说明如何利用C语言特性进行具体的优化措施。如果可能，请给出部分优化后的代码示例。
41.1万 热度难度
编程语言C

知识考点

AI 面试

面试题答案

一键面试

内存管理优化

  1. 避免频繁内存分配和释放：在服务器启动时预先分配一大块内存，使用内存池来管理。当处理请求需要内存时，从内存池获取，请求处理完毕后归还到内存池。
    • C语言实现：
#include <stdio.h>
#include <stdlib.h>

#define MEM_POOL_SIZE 1024 * 1024 // 1MB内存池
#define CHUNK_SIZE 1024 // 每个内存块大小

typedef struct MemoryChunk {
    struct MemoryChunk *next;
} MemoryChunk;

typedef struct MemoryPool {
    MemoryChunk *freeList;
    char pool[MEM_POOL_SIZE];
} MemoryPool;

MemoryPool* createMemoryPool() {
    MemoryPool *pool = (MemoryPool*)malloc(sizeof(MemoryPool));
    if (!pool) {
        return NULL;
    }
    char *current = pool->pool;
    pool->freeList = (MemoryChunk*)current;
    for (int i = 0; i < MEM_POOL_SIZE / CHUNK_SIZE - 1; i++) {
        ((MemoryChunk*)current)->next = (MemoryChunk*)(current + CHUNK_SIZE);
        current += CHUNK_SIZE;
    }
    ((MemoryChunk*)current)->next = NULL;
    return pool;
}

void* allocateFromPool(MemoryPool *pool) {
    if (!pool->freeList) {
        return NULL;
    }
    MemoryChunk *chunk = pool->freeList;
    pool->freeList = chunk->next;
    return chunk;
}

void freeToPool(MemoryPool *pool, void *chunk) {
    ((MemoryChunk*)chunk)->next = pool->freeList;
    pool->freeList = (MemoryChunk*)chunk;
}
  1. 优化数据结构内存布局：对于频繁访问的数据结构，尽量使成员变量按照数据类型大小顺序排列，减少内存空洞，提高缓存命中率。例如，对于一个存储HTTP请求信息的结构体：
typedef struct HttpRequest {
    int requestId; // 4字节
    char method[8]; // 8字节
    char url[256]; // 256字节
    // 其他成员变量按顺序排列
} HttpRequest;

线程/进程模型优化

  1. 多线程模型：采用线程池技术，避免每次请求都创建和销毁线程的开销。
    • C语言实现：
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define THREAD_POOL_SIZE 10

typedef struct Task {
    void (*func)(void*);
    void *arg;
    struct Task *next;
} Task;

typedef struct ThreadPool {
    pthread_t threads[THREAD_POOL_SIZE];
    Task *taskQueue;
    pthread_mutex_t queueMutex;
    pthread_cond_t queueCond;
    int stop;
} ThreadPool;

void* worker(void* arg) {
    ThreadPool *pool = (ThreadPool*)arg;
    while (1) {
        pthread_mutex_lock(&pool->queueMutex);
        while (!pool->taskQueue &&!pool->stop) {
            pthread_cond_wait(&pool->queueCond, &pool->queueMutex);
        }
        if (pool->stop &&!pool->taskQueue) {
            pthread_mutex_unlock(&pool->queueMutex);
            pthread_exit(NULL);
        }
        Task *task = pool->taskQueue;
        pool->taskQueue = task->next;
        pthread_mutex_unlock(&pool->queueMutex);

        task->func(task->arg);
        free(task);
    }
}

ThreadPool* createThreadPool() {
    ThreadPool *pool = (ThreadPool*)malloc(sizeof(ThreadPool));
    if (!pool) {
        return NULL;
    }
    pool->taskQueue = NULL;
    pool->stop = 0;
    pthread_mutex_init(&pool->queueMutex, NULL);
    pthread_cond_init(&pool->queueCond, NULL);
    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_create(&pool->threads[i], NULL, worker, pool);
    }
    return pool;
}

void addTask(ThreadPool *pool, void (*func)(void*), void *arg) {
    Task *task = (Task*)malloc(sizeof(Task));
    task->func = func;
    task->arg = arg;
    task->next = NULL;

    pthread_mutex_lock(&pool->queueMutex);
    if (!pool->taskQueue) {
        pool->taskQueue = task;
    } else {
        Task *current = pool->taskQueue;
        while (current->next) {
            current = current->next;
        }
        current->next = task;
    }
    pthread_cond_signal(&pool->queueCond);
    pthread_mutex_unlock(&pool->queueMutex);
}

void destroyThreadPool(ThreadPool *pool) {
    pthread_mutex_lock(&pool->queueMutex);
    pool->stop = 1;
    pthread_cond_broadcast(&pool->queueCond);
    pthread_mutex_unlock(&pool->queueMutex);

    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_join(pool->threads[i], NULL);
    }
    pthread_mutex_destroy(&pool->queueMutex);
    pthread_cond_destroy(&pool->queueCond);
    while (pool->taskQueue) {
        Task *task = pool->taskQueue;
        pool->taskQueue = task->next;
        free(task);
    }
    free(pool);
}
  1. 多进程模型：可以使用fork创建子进程来处理请求，利用操作系统的进程调度机制。但进程间通信相对复杂，需要注意资源共享和同步问题。例如，使用共享内存和信号量来实现进程间通信和同步。
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <unistd.h>

#define SHM_SIZE 1024

int main() {
    key_t key = ftok(".", 'a');
    int shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0666);
    if (shmid == -1) {
        perror("shmget");
        return 1;
    }
    char *sharedMem = (char*)shmat(shmid, NULL, 0);
    if (sharedMem == (void*)-1) {
        perror("shmat");
        return 1;
    }

    sem_t *semaphore = sem_open("/semaphore", O_CREAT, 0666, 1);
    if (semaphore == SEM_FAILED) {
        perror("sem_open");
        return 1;
    }

    pid_t pid = fork();
    if (pid == -1) {
        perror("fork");
        return 1;
    } else if (pid == 0) { // 子进程
        sem_wait(semaphore);
        // 处理请求，修改共享内存
        snprintf(sharedMem, SHM_SIZE, "Child process has written");
        sem_post(semaphore);
        shmdt(sharedMem);
        sem_close(semaphore);
        exit(0);
    } else { // 父进程
        sem_wait(semaphore);
        // 处理请求，读取共享内存
        printf("Parent read: %s\n", sharedMem);
        sem_post(semaphore);
        wait(NULL);
        shmdt(sharedMem);
        shmctl(shmid, IPC_RMID, NULL);
        sem_close(semaphore);
        sem_unlink("/semaphore");
    }
    return 0;
}

I/O多路复用优化

  1. 使用select：通过select函数可以同时监听多个文件描述符，当有事件发生时进行处理。
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define PORT 8080
#define BACKLOG 10

int main() {
    int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == -1) {
        perror("socket");
        return 1;
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PORT);
    serverAddr.sin_addr.s_addr = INADDR_ANY;

    if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
        perror("bind");
        close(serverSocket);
        return 1;
    }

    if (listen(serverSocket, BACKLOG) == -1) {
        perror("listen");
        close(serverSocket);
        return 1;
    }

    fd_set readFds;
    FD_ZERO(&readFds);
    FD_SET(serverSocket, &readFds);
    fd_set tmpFds = readFds;

    while (1) {
        int activity = select(serverSocket + 1, &tmpFds, NULL, NULL, NULL);
        if (activity == -1) {
            perror("select");
            break;
        } else if (activity > 0) {
            if (FD_ISSET(serverSocket, &tmpFds)) {
                int clientSocket = accept(serverSocket, NULL, NULL);
                if (clientSocket != -1) {
                    FD_SET(clientSocket, &readFds);
                }
            }
            for (int i = 0; i <= serverSocket; i++) {
                if (FD_ISSET(i, &tmpFds) && i != serverSocket) {
                    char buffer[1024];
                    int bytesRead = recv(i, buffer, sizeof(buffer), 0);
                    if (bytesRead <= 0) {
                        close(i);
                        FD_CLR(i, &readFds);
                    } else {
                        // 处理HTTP请求
                        buffer[bytesRead] = '\0';
                        printf("Received: %s\n", buffer);
                        // 发送响应
                        const char *response = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nHello, World!";
                        send(i, response, strlen(response), 0);
                    }
                }
            }
        }
        tmpFds = readFds;
    }
    close(serverSocket);
    return 0;
}
  1. 使用epoll：在Linux系统下，epoll比select性能更优，尤其是在处理大量并发连接时。epoll采用事件驱动的方式，避免了每次调用都扫描所有文件描述符。
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#define PORT 8080
#define BACKLOG 10
#define MAX_EVENTS 10

int main() {
    int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
    if (serverSocket == -1) {
        perror("socket");
        return 1;
    }

    struct sockaddr_in serverAddr;
    serverAddr.sin_family = AF_INET;
    serverAddr.sin_port = htons(PORT);
    serverAddr.sin_addr.s_addr = INADDR_ANY;

    if (bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr)) == -1) {
        perror("bind");
        close(serverSocket);
        return 1;
    }

    if (listen(serverSocket, BACKLOG) == -1) {
        perror("listen");
        close(serverSocket);
        return 1;
    }

    int epollFd = epoll_create1(0);
    if (epollFd == -1) {
        perror("epoll_create1");
        close(serverSocket);
        return 1;
    }

    struct epoll_event event;
    event.data.fd = serverSocket;
    event.events = EPOLLIN;
    if (epoll_ctl(epollFd, EPOLL_CTL_ADD, serverSocket, &event) == -1) {
        perror("epoll_ctl: serverSocket");
        close(serverSocket);
        close(epollFd);
        return 1;
    }

    struct epoll_event events[MAX_EVENTS];
    while (1) {
        int numEvents = epoll_wait(epollFd, events, MAX_EVENTS, -1);
        if (numEvents == -1) {
            perror("epoll_wait");
            break;
        }
        for (int i = 0; i < numEvents; i++) {
            if (events[i].data.fd == serverSocket) {
                int clientSocket = accept(serverSocket, NULL, NULL);
                if (clientSocket == -1) {
                    perror("accept");
                    continue;
                }
                event.data.fd = clientSocket;
                event.events = EPOLLIN | EPOLLET; // 边缘触发模式
                if (epoll_ctl(epollFd, EPOLL_CTL_ADD, clientSocket, &event) == -1) {
                    perror("epoll_ctl: clientSocket");
                    close(clientSocket);
                }
            } else {
                int clientSocket = events[i].data.fd;
                char buffer[1024];
                ssize_t bytesRead = recv(clientSocket, buffer, sizeof(buffer), 0);
                if (bytesRead <= 0) {
                    if (bytesRead == 0) {
                        // 连接关闭
                        printf("Connection closed by peer\n");
                    } else {
                        perror("recv");
                    }
                    close(clientSocket);
                    epoll_ctl(epollFd, EPOLL_CTL_DEL, clientSocket, NULL);
                } else {
                    buffer[bytesRead] = '\0';
                    printf("Received: %s\n", buffer);
                    const char *response = "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\n\r\nHello, World!";
                    send(clientSocket, response, strlen(response), 0);
                }
            }
        }
    }
    close(serverSocket);
    close(epollFd);
    return 0;
}