面试题：C语言线程创建中上下文切换对性能的影响及优化

Question

在Linux系统下使用C语言创建多个线程，上下文切换会对程序性能产生怎样的影响？你可以从哪些方面进行优化来减少上下文切换带来的开销？请结合具体代码示例说明。

Answer 1

上下文切换对程序性能的影响

1. 时间开销：上下文切换需要保存和恢复线程的寄存器状态、程序计数器等信息，这会占用CPU时间，导致实际用于执行用户代码的时间减少。例如，假设每个上下文切换花费10微秒，如果频繁切换，对于一个原本执行时间较短的任务，这些开销可能占比较大。
2. 缓存影响：切换上下文时，CPU缓存中的数据可能不再适用新线程，导致缓存命中率降低。新线程可能需要重新从内存中读取数据，增加内存访问延迟。

优化上下文切换开销的方面

1. 减少线程数量：避免创建过多不必要的线程，减少上下文切换的频率。例如，在一个简单的计算任务中，如果可以通过单线程或者少量线程完成，就不要创建大量线程。
2. 线程池：使用线程池管理线程，复用线程，减少线程创建和销毁的开销，进而减少上下文切换。
3. 优化调度策略：选择合适的调度算法，如SCHED_FIFO或SCHED_RR（实时调度策略），根据任务的优先级合理分配CPU时间，减少不必要的上下文切换。

代码示例 - 使用线程池优化上下文切换

下面是一个简单的线程池示例代码，展示如何通过线程池减少线程创建和上下文切换开销。

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

#define THREAD_POOL_SIZE 5
#define TASK_QUEUE_SIZE 10

// 任务结构体
typedef struct {
    void (*function)(void*);
    void *arg;
} task_t;

// 线程池结构体
typedef struct {
    pthread_t *threads;
    task_t task_queue[TASK_QUEUE_SIZE];
    int queue_head;
    int queue_tail;
    int queue_count;
    pthread_mutex_t mutex;
    pthread_cond_t cond;
    int stop;
} thread_pool_t;

// 初始化线程池
void init_thread_pool(thread_pool_t *pool) {
    pool->threads = (pthread_t *)malloc(THREAD_POOL_SIZE * sizeof(pthread_t));
    pool->queue_head = 0;
    pool->queue_tail = 0;
    pool->queue_count = 0;
    pool->stop = 0;

    pthread_mutex_init(&pool->mutex, NULL);
    pthread_cond_init(&pool->cond, NULL);

    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_create(&pool->threads[i], NULL, (void *(*)(void *))[](void *arg) {
            thread_pool_t *pool = (thread_pool_t *)arg;
            while (1) {
                task_t task;
                pthread_mutex_lock(&pool->mutex);
                while (pool->queue_count == 0 &&!pool->stop) {
                    pthread_cond_wait(&pool->cond, &pool->mutex);
                }
                if (pool->stop && pool->queue_count == 0) {
                    pthread_mutex_unlock(&pool->mutex);
                    pthread_exit(NULL);
                }
                task = pool->task_queue[pool->queue_head];
                pool->queue_head = (pool->queue_head + 1) % TASK_QUEUE_SIZE;
                pool->queue_count--;
                pthread_mutex_unlock(&pool->mutex);

                task.function(task.arg);
            }
            return NULL;
        }, pool);
    }
}

// 添加任务到线程池
void add_task(thread_pool_t *pool, void (*function)(void*), void *arg) {
    pthread_mutex_lock(&pool->mutex);
    while (pool->queue_count == TASK_QUEUE_SIZE) {
        pthread_cond_wait(&pool->cond, &pool->mutex);
    }
    pool->task_queue[pool->queue_tail] = (task_t){function, arg};
    pool->queue_tail = (pool->queue_tail + 1) % TASK_QUEUE_SIZE;
    pool->queue_count++;
    pthread_cond_signal(&pool->cond);
    pthread_mutex_unlock(&pool->mutex);
}

// 销毁线程池
void destroy_thread_pool(thread_pool_t *pool) {
    pthread_mutex_lock(&pool->mutex);
    pool->stop = 1;
    pthread_cond_broadcast(&pool->cond);
    pthread_mutex_unlock(&pool->mutex);

    for (int i = 0; i < THREAD_POOL_SIZE; i++) {
        pthread_join(pool->threads[i], NULL);
    }

    pthread_mutex_destroy(&pool->mutex);
    pthread_cond_destroy(&pool->cond);
    free(pool->threads);
}

// 示例任务函数
void example_task(void *arg) {
    printf("Task is running with argument: %d\n", *((int *)arg));
    sleep(1);
}

int main() {
    thread_pool_t pool;
    init_thread_pool(&pool);

    int args[5] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++) {
        add_task(&pool, example_task, &args[i]);
    }

    sleep(2);
    destroy_thread_pool(&pool);

    return 0;
}

在这个示例中，通过线程池复用线程，避免了频繁创建和销毁线程，从而减少上下文切换开销。线程池中的线程持续运行，从任务队列中获取任务执行，减少了上下文切换的次数，提高了程序性能。