面试题：C语言中Linux Socket并发编程的性能优化

可能导致上下文切换频繁的原因

多线程竞争资源：多个线程同时访问共享资源，如临界区、锁等，导致线程等待资源而频繁切换上下文。
系统调用过多：频繁进行系统调用，如I/O操作（read、write等），每次系统调用都会引发用户态到内核态的切换，增加上下文切换开销。
线程调度不合理：线程的调度策略不合理，例如线程优先级设置不当，导致高优先级线程频繁抢占低优先级线程，造成不必要的上下文切换。

优化方案

减少线程竞争
- C语言代码层面实现：使用无锁数据结构（如无锁队列、无锁哈希表）来避免锁竞争。以无锁队列为例，在queue.h中定义无锁队列结构和操作函数：

// queue.h
#include <stdint.h>
#include <pthread.h>

typedef struct {
    int *data;
    uint32_t head;
    uint32_t tail;
    uint32_t capacity;
    pthread_spinlock_t lock;
} lock_free_queue;

void queue_init(lock_free_queue *q, uint32_t capacity);
int queue_enqueue(lock_free_queue *q, int value);
int queue_dequeue(lock_free_queue *q, int *value);

在queue.c中实现这些函数：

// queue.c
#include "queue.h"
#include <stdlib.h>

void queue_init(lock_free_queue *q, uint32_t capacity) {
    q->data = (int *)malloc(capacity * sizeof(int));
    q->head = 0;
    q->tail = 0;
    q->capacity = capacity;
    pthread_spin_init(&q->lock, PTHREAD_PROCESS_PRIVATE);
}

int queue_enqueue(lock_free_queue *q, int value) {
    pthread_spin_lock(&q->lock);
    uint32_t next_tail = (q->tail + 1) % q->capacity;
    if (next_tail == q->head) {
        pthread_spin_unlock(&q->lock);
        return 0; // 队列满
    }
    q->data[q->tail] = value;
    q->tail = next_tail;
    pthread_spin_unlock(&q->lock);
    return 1;
}

int queue_dequeue(lock_free_queue *q, int *value) {
    pthread_spin_lock(&q->lock);
    if (q->head == q->tail) {
        pthread_spin_unlock(&q->lock);
        return 0; // 队列空
    }
    *value = q->data[q->head];
    q->head = (q->head + 1) % q->capacity;
    pthread_spin_unlock(&q->lock);
    return 1;
}

- **其他影响**：无锁数据结构实现较为复杂，代码可读性可能变差。并且在某些情况下，可能会增加CPU缓存争用，因为无锁数据结构通常需要更频繁地访问共享内存。

2. 减少系统调用 - C语言代码层面实现：使用缓冲区技术，例如在网络I/O中，先将数据写入用户空间缓冲区，然后批量调用系统函数发送数据。以下是一个简单的示例：

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

#define BUFFER_SIZE 1024

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(8080);
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");

    connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));

    char buffer[BUFFER_SIZE];
    // 模拟数据写入缓冲区
    strcpy(buffer, "Hello, Server!");
    // 批量发送数据
    send(sockfd, buffer, strlen(buffer), 0);

    close(sockfd);
    return 0;
}

- **其他影响**：引入缓冲区会增加内存的使用，并且需要合理管理缓冲区的大小和生命周期，否则可能会导致内存泄漏或数据丢失。

3. 优化线程调度 - C语言代码层面实现：使用POSIX线程库来设置线程优先级。例如，将重要的网络处理线程设置为较高优先级：

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

void* thread_function(void* arg) {
    // 设置线程优先级
    struct sched_param param;
    param.sched_priority = sched_get_priority_max(SCHED_FIFO);
    pthread_setschedparam(pthread_self(), SCHED_FIFO, &param);
    // 线程工作代码
    printf("Thread with high priority is running.\n");
    return NULL;
}

int main() {
    pthread_t thread;
    pthread_create(&thread, NULL, thread_function, NULL);
    pthread_join(thread, NULL);
    return 0;
}

- **其他影响**：如果优先级设置不当，可能导致低优先级线程饥饿，长时间得不到执行机会。同时，过高优先级的线程可能会占用过多CPU资源，影响系统整体的公平性和稳定性。

星途面试题库

面试题：C语言中Linux Socket并发编程的性能优化

知识考点

面试题答案

可能导致上下文切换频繁的原因

优化方案