当前位置：首页 > news >正文

Linux 多线程编程实战指南

news 来源：原创 2025/6/21 7:55:23

Linux 多线程编程实战指南

前言

多线程编程是现代软件开发中不可或缺的技术，它能够充分利用多核处理器的性能，提高程序的执行效率。本文将从实践角度详细介绍 Linux 多线程编程的核心知识。

一、多线程基础

1.1 为什么需要多线程？

提高程序响应性
充分利用多核处理器
资源共享效率高
降低系统开销

1.2 线程与进程的区别

资源共享方面
创建和切换开销
通信机制
编程复杂度

二、POSIX 线程编程

2.1 线程创建与终止

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

void* thread_function(void* arg) {
    int thread_id = *(int*)arg;
    printf("线程 %d 开始执行\n", thread_id);
    
    // 线程执行的工作
    for(int i = 0; i < 5; i++) {
        printf("线程 %d: 计数 %d\n", thread_id, i);
        sleep(1);
    }
    
    printf("线程 %d 执行完毕\n", thread_id);
    return NULL;
}

int main() {
    pthread_t threads[3];
    int thread_ids[3] = {1, 2, 3};
    
    // 创建多个线程
    for(int i = 0; i < 3; i++) {
        if(pthread_create(&threads[i], NULL, thread_function, &thread_ids[i]) != 0) {
            perror("线程创建失败");
            exit(1);
        }
    }
    
    // 等待所有线程结束
    for(int i = 0; i < 3; i++) {
        pthread_join(threads[i], NULL);
    }
    
    printf("所有线程执行完毕\n");
    return 0;
}

2.2 线程同步机制

2.2.1 互斥锁

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int shared_counter = 0;

void* safe_increment(void* arg) {
    for(int i = 0; i < 1000000; i++) {
        pthread_mutex_lock(&mutex);
        shared_counter++;
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

2.2.2 条件变量

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condition = PTHREAD_COND_INITIALIZER;
int data_ready = 0;

void* producer(void* arg) {
    while(1) {
        pthread_mutex_lock(&mutex);
        
        // 生产数据
        data_ready = 1;
        printf("数据已生产\n");
        
        // 通知消费者
        pthread_cond_signal(&condition);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    return NULL;
}

void* consumer(void* arg) {
    while(1) {
        pthread_mutex_lock(&mutex);
        
        // 等待数据
        while(!data_ready) {
            pthread_cond_wait(&condition, &mutex);
        }
        
        // 消费数据
        printf("数据已消费\n");
        data_ready = 0;
        
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

三、实战案例：线程池实现

typedef struct {
    void (*function)(void* arg);
    void* arg;
} task_t;

typedef struct {
    task_t* tasks;
    int task_capacity;
    int task_size;
    int task_front;
    int task_rear;
    
    pthread_t* threads;
    int thread_count;
    
    pthread_mutex_t lock;
    pthread_cond_t not_full;
    pthread_cond_t not_empty;
    int shutdown;
} thread_pool_t;

// 线程池初始化
thread_pool_t* thread_pool_create(int thread_count, int task_capacity) {
    thread_pool_t* pool = malloc(sizeof(thread_pool_t));
    
    pool->tasks = malloc(sizeof(task_t) * task_capacity);
    pool->task_capacity = task_capacity;
    pool->task_size = 0;
    pool->task_front = 0;
    pool->task_rear = 0;
    
    pool->threads = malloc(sizeof(pthread_t) * thread_count);
    pool->thread_count = thread_count;
    
    pthread_mutex_init(&pool->lock, NULL);
    pthread_cond_init(&pool->not_full, NULL);
    pthread_cond_init(&pool->not_empty, NULL);
    pool->shutdown = 0;
    
    // 创建工作线程
    for(int i = 0; i < thread_count; i++) {
        pthread_create(&pool->threads[i], NULL, worker_thread, pool);
    }
    
    return pool;
}