面试题：网络编程下IO多路复用在高并发场景的性能优化策略

操作系统参数调整

文件描述符限制：通过修改ulimit -n参数，提高进程可打开的文件描述符数量，确保能处理大量并发连接。例如在Linux系统中，可通过编辑/etc/security/limits.conf文件，添加或修改* soft nofile 65535和* hard nofile 65535，让进程能打开更多连接。
TCP缓冲区大小：调整TCP接收和发送缓冲区大小，优化数据传输性能。在Linux下，可修改/proc/sys/net/ipv4/tcp_rmem和/proc/sys/net/ipv4/tcp_wmem，分别设置接收和发送缓冲区的最小值、默认值和最大值。如echo "4096 87380 16777216" > /proc/sys/net/ipv4/tcp_rmem，根据实际情况设置合适的值，避免缓冲区过小导致数据丢失或过大浪费内存。
内核调度算法：选择合适的内核调度算法，如在Linux中，对于I/O密集型应用，可考虑使用CFQ（完全公平队列）调度算法，能更好地分配I/O资源，提升整体性能。通过修改/sys/block/sda/queue/scheduler（假设磁盘设备为sda），选择合适的调度算法。

代码实现细节

合理选择I/O多路复用模型：不同的I/O多路复用模型在不同场景下性能有差异。例如epoll在Linux上处理大量并发连接性能较好，它采用事件驱动机制，通过epoll_ctl添加、修改或删除监听事件，epoll_wait等待事件发生。相比select和poll，它没有文件描述符数量限制，并且在高并发时性能更优。在代码中应优先选择epoll，如：

int epollFd = epoll_create1(0);
if (epollFd == -1) {
    perror("epoll_create1");
    return -1;
}
struct epoll_event event;
event.data.fd = sockfd;
event.events = EPOLLIN | EPOLLET;
if (epoll_ctl(epollFd, EPOLL_CTL_ADD, sockfd, &event) == -1) {
    perror("epoll_ctl: sockfd");
    close(sockfd);
    close(epollFd);
    return -1;
}

减少系统调用开销：系统调用开销相对较大，应尽量减少不必要的系统调用。例如在处理网络数据时，可使用readv和writev函数，一次系统调用读写多个缓冲区，减少系统调用次数。如：

struct iovec iov[2];
iov[0].iov_base = buf1;
iov[0].iov_len = len1;
iov[1].iov_base = buf2;
iov[1].iov_len = len2;
ssize_t n = readv(sockfd, iov, 2);

优化内存管理：在处理大量并发连接时，频繁的内存分配和释放会影响性能。可采用内存池技术，预先分配一块较大的内存，当需要时从内存池中分配小块内存，使用完毕后再归还到内存池，避免频繁调用malloc和free。例如：

// 简单内存池示例
typedef struct MemoryBlock {
    struct MemoryBlock* next;
    char data[BLOCK_SIZE];
} MemoryBlock;

typedef struct MemoryPool {
    MemoryBlock* freeList;
} MemoryPool;

MemoryPool* createMemoryPool() {
    MemoryPool* pool = (MemoryPool*)malloc(sizeof(MemoryPool));
    pool->freeList = NULL;
    return pool;
}

void* allocateFromPool(MemoryPool* pool) {
    if (pool->freeList == NULL) {
        MemoryBlock* newBlock = (MemoryBlock*)malloc(sizeof(MemoryBlock));
        newBlock->next = pool->freeList;
        pool->freeList = newBlock;
    }
    MemoryBlock* block = pool->freeList;
    pool->freeList = block->next;
    return block->data;
}

void freeToPool(MemoryPool* pool, void* ptr) {
    MemoryBlock* block = (MemoryBlock*)((char*)ptr - offsetof(MemoryBlock, data));
    block->next = pool->freeList;
    pool->freeList = block;
}

异步处理：对于一些耗时操作，如磁盘I/O、数据库查询等，采用异步方式处理。在网络编程中，可使用线程池或异步I/O库（如libaio在Linux下）。例如使用线程池处理数据库查询，主线程继续处理网络连接，避免阻塞I/O多路复用循环。以简单线程池示例：

// 简单线程池示例
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

#define MAX_THREADS 10
#define MAX_JOBS 100

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

typedef struct ThreadPool {
    pthread_t threads[MAX_THREADS];
    Job* jobQueue;
    Job* tail;
    int queueSize;
    int isShutdown;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
} ThreadPool;

ThreadPool* createThreadPool() {
    ThreadPool* pool = (ThreadPool*)malloc(sizeof(ThreadPool));
    pool->jobQueue = NULL;
    pool->tail = NULL;
    pool->queueSize = 0;
    pool->isShutdown = 0;
    pthread_mutex_init(&pool->mutex, NULL);
    pthread_cond_init(&pool->cond, NULL);
    for (int i = 0; i < MAX_THREADS; i++) {
        pthread_create(&pool->threads[i], NULL, worker, (void*)pool);
    }
    return pool;
}

void addJob(ThreadPool* pool, void (*func)(void*), void* arg) {
    Job* newJob = (Job*)malloc(sizeof(Job));
    newJob->func = func;
    newJob->arg = arg;
    newJob->next = NULL;
    pthread_mutex_lock(&pool->mutex);
    if (pool->tail == NULL) {
        pool->jobQueue = newJob;
    } else {
        pool->tail->next = newJob;
    }
    pool->tail = newJob;
    pool->queueSize++;
    pthread_cond_signal(&pool->cond);
    pthread_mutex_unlock(&pool->mutex);
}

void* worker(void* arg) {
    ThreadPool* pool = (ThreadPool*)arg;
    while (1) {
        Job* job;
        pthread_mutex_lock(&pool->mutex);
        while (pool->queueSize == 0 &&!pool->isShutdown) {
            pthread_cond_wait(&pool->cond, &pool->mutex);
        }
        if (pool->isShutdown && pool->queueSize == 0) {
            pthread_mutex_unlock(&pool->mutex);
            pthread_exit(NULL);
        }
        job = pool->jobQueue;
        pool->jobQueue = job->next;
        if (pool->jobQueue == NULL) {
            pool->tail = NULL;
        }
        pool->queueSize--;
        pthread_mutex_unlock(&pool->mutex);
        (*job->func)(job->arg);
        free(job);
    }
    return NULL;
}

void shutdownThreadPool(ThreadPool* pool) {
    pthread_mutex_lock(&pool->mutex);
    pool->isShutdown = 1;
    pthread_cond_broadcast(&pool->cond);
    pthread_mutex_unlock(&pool->mutex);
    for (int i = 0; i < MAX_THREADS; i++) {
        pthread_join(pool->threads[i], NULL);
    }
    pthread_mutex_destroy(&pool->mutex);
    pthread_cond_destroy(&pool->cond);
    free(pool);
}

使用高效数据结构：选择合适的数据结构存储连接相关信息。例如使用哈希表存储客户端连接信息，通过哈希值快速定位连接，相比线性查找，在处理大量连接时能显著提高查找效率。如：

// 简单哈希表示例
#define HASH_TABLE_SIZE 1024

typedef struct Connection {
    int sockfd;
    // 其他连接相关信息
    struct Connection* next;
} Connection;

typedef struct HashTable {
    Connection* table[HASH_TABLE_SIZE];
} HashTable;

unsigned long hashFunction(int sockfd) {
    return sockfd % HASH_TABLE_SIZE;
}

void addConnection(HashTable* table, int sockfd) {
    unsigned long index = hashFunction(sockfd);
    Connection* newConn = (Connection*)malloc(sizeof(Connection));
    newConn->sockfd = sockfd;
    newConn->next = table->table[index];
    table->table[index] = newConn;
}

Connection* findConnection(HashTable* table, int sockfd) {
    unsigned long index = hashFunction(sockfd);
    Connection* conn = table->table[index];
    while (conn != NULL) {
        if (conn->sockfd == sockfd) {
            return conn;
        }
        conn = conn->next;
    }
    return NULL;
}

星途面试题库

面试题：网络编程下IO多路复用在高并发场景的性能优化策略

知识考点

面试题答案

操作系统参数调整

代码实现细节