请求详解User thread与Kernel thread的差异及实用示例

本质区别 #

说白了，两者的核心差异在于谁来管控它们：

• 用户空间线程：完全是用户程序自己实现的“轻量任务单元”，操作系统内核根本不知道它们的存在，全靠用户态的线程库负责调度管理。
• 内核空间线程：是操作系统内核直接认可的执行单元，线程的创建、调度、销毁全由内核一手操办，内核对每个线程的状态了如指掌。

关键差异点 #

• 调度开销：用户空间线程切换不用跟内核打交道，直接在用户态完成，速度快、开销极小；内核线程切换需要保存/恢复内核上下文，还要走内核调度逻辑，开销大很多。
• 多核利用：因为内核看不到用户空间线程，所以一个进程里的所有用户线程只能挤在同一个CPU核上跑，没法利用多核资源；内核线程可以被内核分配到不同的CPU核，真正实现并行计算。
• 阻塞影响：如果一个用户空间线程阻塞（比如调用sleep、等待IO），整个进程的所有用户线程都会跟着卡住——因为内核只认进程，会把整个进程挂起；内核线程则不会，一个线程阻塞，其他线程照样能被内核调度运行。
• 资源占用：用户空间线程轻量，创建、销毁速度快，占用内存少；内核线程创建销毁需要内核参与分配资源，相对笨重。

实用示例 #

示例1：用户空间线程（GNU Pth库实现）

早期的Ruby MRI（1.8版本及以前）用的就是用户空间线程，典型特征是没法利用多核，一个线程阻塞会拖垮整个进程。下面是一个简单示例：

#include <pth.h>
#include <stdio.h>

void* user_thread_func(void* arg) {
    int thread_id = *(int*)arg;
    for (int i = 0; i < 5; i++) {
        printf("用户线程%d：执行第%d次任务\n", thread_id, i);
        pth_yield(NULL); // 主动让出CPU给其他用户线程（用户态调度）
    }
    return NULL;
}

int main() {
    pth_init(); // 初始化用户态线程库
    int id1 = 1, id2 = 2;
    
    // 创建两个用户空间线程
    pth_t t1 = pth_spawn(PTH_ATTR_DEFAULT, user_thread_func, &id1);
    pth_t t2 = pth_spawn(PTH_ATTR_DEFAULT, user_thread_func, &id2);
    
    pth_join(t1, NULL); // 等待线程结束
    pth_join(t2, NULL);
    pth_kill(); // 销毁线程库资源
    return 0;
}

这个程序里的两个线程，内核完全感知不到，所有切换逻辑都由Pth库在用户态处理，整个进程只会占用一个CPU核心。

示例2：内核空间线程（Linux pthread实现）

Linux下默认的pthread线程就是内核空间线程，能利用多核，线程阻塞不影响其他线程。下面是一个并行计算求和的示例：

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

#define THREAD_COUNT 4
long long total_sum = 0;
pthread_mutex_t sum_mutex;

void* kernel_thread_func(void* arg) {
    int thread_id = *(int*)arg;
    long long local_sum = 0;
    
    // 每个线程负责计算1/4的数值范围
    long long start = thread_id * 250000LL;
    long long end = (thread_id + 1) * 250000LL;
    for (long long i = start; i < end; i++) {
        local_sum += i;
    }
    
    // 加锁更新全局总和
    pthread_mutex_lock(&sum_mutex);
    total_sum += local_sum;
    pthread_mutex_unlock(&sum_mutex);
    
    printf("内核线程%d：完成计算，局部和为%lld\n", thread_id, local_sum);
    return NULL;
}

int main() {
    pthread_t threads[THREAD_COUNT];
    int thread_ids[THREAD_COUNT];
    pthread_mutex_init(&sum_mutex, NULL);
    
    // 创建4个内核空间线程
    for (int i = 0; i < THREAD_COUNT; i++) {
        thread_ids[i] = i;
        pthread_create(&threads[i], NULL, kernel_thread_func, &thread_ids[i]);
    }
    
    // 等待所有线程结束
    for (int i = 0; i < THREAD_COUNT; i++) {
        pthread_join(threads[i], NULL);
    }
    
    printf("最终总和：%lld\n", total_sum);
    pthread_mutex_destroy(&sum_mutex);
    return 0;
}

这个程序的4个线程会被Linux内核调度到不同的CPU核心上并行执行，真正利用多核资源提升计算速度。

内容的提问来源于stack exchange，提问作者kamalu922