面试题：C语言自定义Linux信号类型与系统资源管理及性能优化

可能导致性能下降的原因

信号处理函数开销：信号处理函数中执行了复杂的操作，如大量的内存分配/释放、I/O 操作或复杂的计算，这会占用大量 CPU 时间，导致系统性能下降。例如，在信号处理函数中直接调用 malloc 或 free 等函数，这些函数本身不是异步信号安全的，频繁调用可能导致未定义行为和性能问题。
上下文切换开销：每次信号触发时，系统需要进行上下文切换，保存当前进程的状态并切换到信号处理函数执行。在高并发环境下，频繁的上下文切换会消耗大量的 CPU 时间，降低系统整体性能。
资源竞争：如果信号处理函数和主程序共享某些资源（如全局变量、文件描述符等），在高并发情况下可能会出现资源竞争，导致锁争用，从而降低性能。例如，主程序和信号处理函数都对同一个全局链表进行操作，没有适当的同步机制，会导致数据不一致和性能瓶颈。
系统资源分配/释放策略不合理：如果在信号处理函数中进行资源释放时，没有考虑到高并发环境下的资源复用和预分配机制，可能会导致频繁的系统调用，如 mmap 和 munmap，增加系统开销。

优化方案

信号处理函数设计
- 保持信号处理函数简单：信号处理函数应尽可能简单，只执行必要的操作，避免复杂的计算和非异步信号安全的函数调用。例如，对于特定内存块的释放，可以先设置一个标志位，让主程序在合适的时机进行实际的内存释放操作。

#include <signal.h>
#include <stdio.h>

volatile sig_atomic_t should_free_memory = 0;

void signal_handler(int signum) {
    should_free_memory = 1;
}

- **使用异步信号安全函数**：如果必须在信号处理函数中执行一些操作，应确保使用异步信号安全的函数。例如，`write` 函数通常是异步信号安全的，可以用于简单的日志记录等操作。

#include <unistd.h>
#include <signal.h>

void signal_handler(int signum) {
    write(STDOUT_FILENO, "Signal received\n", 15);
}

系统资源分配和释放策略调整
- 资源预分配：在程序启动时，预先分配好可能需要的资源，避免在信号处理函数或高并发执行过程中频繁分配和释放资源。例如，对于特定内存块的场景，可以在程序开始时使用 mmap 分配一大块内存，然后在需要时从这块内存中分配子块。

#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>

#define MEM_SIZE 1024 * 1024
void *preallocated_memory;

int main() {
    int fd = open("/dev/zero", O_RDONLY);
    preallocated_memory = mmap(NULL, MEM_SIZE, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
    if (preallocated_memory == MAP_FAILED) {
        perror("mmap");
        exit(1);
    }
    close(fd);
    // 后续使用 preallocated_memory 进行内存分配
    return 0;
}

- **资源复用**：设计一个资源池，当资源被释放时，将其放回资源池而不是直接归还给系统，下次需要时从资源池中获取。例如，可以使用链表来实现一个简单的内存块资源池。

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

typedef struct MemoryBlock {
    struct MemoryBlock *next;
    // 实际数据部分
} MemoryBlock;

MemoryBlock *memory_pool = NULL;

MemoryBlock* get_memory_block() {
    if (memory_pool) {
        MemoryBlock *block = memory_pool;
        memory_pool = memory_pool->next;
        return block;
    }
    return (MemoryBlock*)malloc(sizeof(MemoryBlock));
}

void return_memory_block(MemoryBlock *block) {
    block->next = memory_pool;
    memory_pool = block;
}

减少上下文切换开销
- 使用线程处理信号：可以使用线程来处理信号，将信号处理逻辑放到单独的线程中，这样可以减少主程序上下文切换的频率。在 POSIX 线程库中，可以使用 pthread_sigmask 来阻塞信号，然后在线程中使用 sigwait 来等待和处理信号。

#include <pthread.h>
#include <signal.h>
#include <stdio.h>

void* signal_thread(void* arg) {
    sigset_t *set = (sigset_t*)arg;
    int signum;
    while (1) {
        if (sigwait(set, &signum) == 0) {
            if (signum == SIGUSR1) {
                // 处理信号逻辑
                printf("Received SIGUSR1 in signal thread\n");
            }
        }
    }
    return NULL;
}

int main() {
    pthread_t thread;
    sigset_t set;
    sigemptyset(&set);
    sigaddset(&set, SIGUSR1);

    pthread_sigmask(SIG_BLOCK, &set, NULL);
    pthread_create(&thread, NULL, signal_thread, (void*)&set);

    // 主程序逻辑
    while (1) {
        // 主程序工作
    }

    pthread_join(thread, NULL);
    return 0;
}

避免资源竞争
- 使用同步机制：如果信号处理函数和主程序共享资源，应使用同步机制（如互斥锁）来避免资源竞争。在 POSIX 线程库中，可以使用 pthread_mutex_t 来保护共享资源。

#include <pthread.h>
#include <signal.h>
#include <stdio.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int shared_variable = 0;

void signal_handler(int signum) {
    pthread_mutex_lock(&mutex);
    shared_variable++;
    pthread_mutex_unlock(&mutex);
}

int main() {
    struct sigaction sa;
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = 0;
    sigaction(SIGUSR1, &sa, NULL);

    // 主程序逻辑
    while (1) {
        pthread_mutex_lock(&mutex);
        printf("Shared variable: %d\n", shared_variable);
        pthread_mutex_unlock(&mutex);
    }

    pthread_mutex_destroy(&mutex);
    return 0;
}

通过以上优化方案，可以有效提高高并发 C 语言程序在处理自定义 Linux 信号时的性能。

星途面试题库

面试题：C语言自定义Linux信号类型与系统资源管理及性能优化

知识考点

面试题答案

可能导致性能下降的原因

优化方案