linux 多线程主线程

基础概念

多线程是指在一个程序中同时运行多个线程，每个线程执行不同的任务。主线程是程序启动时创建的第一个线程，负责执行程序的主要逻辑和控制其他线程的执行。

类型

用户级线程：由应用程序管理，操作系统内核不知道它们的存在。
内核级线程：由操作系统内核管理，每个线程都有独立的内核态。

应用场景

并发处理：如Web服务器处理多个客户端请求。
后台任务：如文件下载、数据处理等可以在后台线程中进行。
实时系统：需要快速响应的系统，如游戏、音视频处理等。

遇到的问题及解决方法

问题1：线程同步问题

原因：多个线程访问共享资源时，可能会发生数据竞争和不一致。

解决方法：

使用互斥锁（mutex）保护共享资源。
使用条件变量（condition variable）进行线程间通信。

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

int shared_data = 0;
pthread_mutex_t mutex;

void* thread_func(void* arg) {
    pthread_mutex_lock(&mutex);
    shared_data++;
    pthread_mutex_unlock(&mutex);
    return NULL;
}

int main() {
    pthread_t threads[10];
    pthread_mutex_init(&mutex, NULL);

    for (int i = 0; i < 10; i++) {
        pthread_create(&threads[i], NULL, thread_func, NULL);
    }

    for (int i = 0; i < 10; i++) {
        pthread_join(threads[i], NULL);
    }

    printf("Shared data: %d\n", shared_data);
    pthread_mutex_destroy(&mutex);
    return 0;
}

问题2：死锁

原因：两个或多个线程互相等待对方释放资源，导致程序无法继续执行。

解决方法：

避免嵌套锁的使用。
使用定时锁（如pthread_mutex_timedlock）。
设计良好的锁顺序。

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

pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutex2 = PTHREAD_MUTEX_INITIALIZER;

void* thread1_func(void* arg) {
    pthread_mutex_lock(&mutex1);
    sleep(1);
    pthread_mutex_lock(&mutex2);
    pthread_mutex_unlock(&mutex2);
    pthread_mutex_unlock(&mutex1);
    return NULL;
}

void* thread2_func(void* arg) {
    pthread_mutex_lock(&mutex2);
    sleep(1);
    pthread_mutex_lock(&mutex1);
    pthread_mutex_unlock(&mutex1);
    pthread_mutex_unlock(&mutex2);
    return NULL;
}

int main() {
    pthread_t thread1, thread2;

    pthread_create(&thread1, NULL, thread1_func, NULL);
    pthread_create(&thread2, NULL, thread2_func, NULL);

    pthread_join(thread1, NULL);
    pthread_join(thread2, NULL);

    return 0;
}

问题3：线程创建过多导致系统资源耗尽

原因：创建大量线程会消耗大量内存和CPU资源。

解决方法：

使用线程池限制线程数量。
合理分配任务，避免频繁创建和销毁线程。

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

#define MAX_THREADS 5

typedef struct {
    void (*func)(void*);
    void* arg;
} Task;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
Task task_queue[MAX_THREADS];
int task_count = 0;

void* worker_thread(void* arg) {
    while (1) {
        pthread_mutex_lock(&mutex);
        while (task_count == 0) {
            pthread_cond_wait(&cond, &mutex);
        }
        Task task = task_queue[--task_count];
        pthread_mutex_unlock(&mutex);

        task.func(task.arg);
    }
    return NULL;
}

void add_task(void (*func)(void*), void* arg) {
    pthread_mutex_lock(&mutex);
    task_queue[task_count].func = func;
    task_queue[task_count].arg = arg;
    task_count++;
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&mutex);
}

void example_task(void* arg) {
    int* num = (int*)arg;
    printf("Task %d executed\n", *num);
}

int main() {
    pthread_t threads[MAX_THREADS];

    for (int i = 0; i < MAX_THREADS; i++) {
        pthread_create(&threads[i], NULL, worker_thread, NULL);
    }

    for (int i = 0; i < 10; i++) {
        int* num = malloc(sizeof(int));
        *num = i;
        add_task(example_task, num);
    }

    for (int i = 0; i < MAX_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }

    return 0;
}

通过以上示例代码和解决方法，可以有效应对Linux多线程编程中常见的问题。