Linux C++ 多线程编程入门：从核心概念到常用函数详解

我们先讲 C 语言的多线程编程，至于 C++ 的线程支持库我们后面也会讲。

注意编译时需链接线程库，由于 C 库没有提供有关多线程的相关操作，对于多线程编程要依赖于第三方库——头文件 #include<pthread.h>，且编译时需要加上 -lpthread 选项。

一、创建线程：pthread_create

我们现在来实践一下此处的创建线程函数，其中我们线程体传递参数不同数目写法也不一样。

向线程体中传递单个数据

注意：传过来的参数必须要进行强转，当然此处若不想添加参数，就直接填 NULL 即可，但线程体中的 void* arg 仍需要填写。

#include<iostream>
#include<cstdio>
#include<cstring>
#include <unistd.h>
#include <pthread.h>
using namespace std;

// 定义线程体函数
void *task(void *arg){
    // arg --> &num 但是 arg 是一个 void* 类型的变量，需要转换为具体指针进行操作
    // (int*)arg --->将其转换为整型的指针
    // *(int *)arg --->num 的值
    int key = *(int*)arg;
    printf("我是分支线程：num = %d\n", key);
}

int main(int argc, const char *argv[]){
    pthread_t tid = -1; // 用于存储线程号的变量
    int num = 520;
    if(pthread_create(&tid, NULL, task, &num) != 0){
        printf("tid create error\n");
        return -1;
    }
    printf("pthread_create success,tid = %#lx\n", tid);
    printf("我是主线程\n");
    num = 1314; // 主线程中更改数据
    printf("主线程中 num = %d\n", num);
    while(1);
    return 0;
}

向线程体中传入多个数据

可以看到，此处若想传递多个数据就必须用到结构体，不能用逗号隔开一个一个传。

#include<iostream>
#include<cstdio>
#include<cstring>
#include <unistd.h>
#include <pthread.h>
using namespace std;

// 定义信息结构体，用于向线程体传递数据
struct Info{
    int num;
    char name[20];
    double score;
};

// 定义线程体函数
void *task(void *arg){
    Info buf = *((Info*)arg); // 将结构体指针转换为结构体变量
    printf("分支线程中：num = %d, name = %s, score = %.2lf\n", buf.num, buf.name, buf.score);
}

int main(int argc, const char *argv[]) {
    pthread_t tid = -1; // 用于存储线程号的变量
    int num = 520;
    char name[20] = "zhangsan";
    double score = 99.5;
    
    // 需求：将上面的三个数据全部传入线程体中
    Info buf = {num, "zhangsan", score};
    if(pthread_create(&tid, NULL, task, &buf) != 0){
        printf("tid create error\n");
        return -1;
    }
    printf("pthread_create success,tid = %#lx\n", tid);
    printf("我是主线程\n");
    while(1);
    return 0;
}

二、线程号的获取：pthread_self

三、线程的退出函数：pthread_exit

四、线程的资源回收：pthread_join

五、线程分离态：pthread_detach

我们不妨更直观的看看四和五的区别：

#include<iostream>
#include<cstdio>
#include<cstring>
#include <unistd.h>
#include <pthread.h>

// 定义线程体函数
void *task(void *arg) {
    printf("分支线程，tid = %#x\n", pthread_self());
    sleep(3);
    pthread_exit(NULL);
}

int main() {
    pthread_t tid = -1;
    // 创建一个线程
    if(pthread_create(&tid, NULL, task, NULL) != 0) {
        printf("pthread_create error\n");
        return -1;
    }
    printf("主线程，tid = %#x\n", tid);
    
    // 回收分支线程的资源
    // pthread_join(tid, NULL); // 前 3 秒，主线程处于休眠等待分支线程的结束
    
    // 将线程设置成分离态 (非阻塞)
    pthread_detach(tid);
    sleep(5);
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

小问题

那我相信肯定也会有人发现，那分离进程如果没运行完，主程序退出后，那么此时分离进程会被回收吗？

答案是：会的，但是线程不会有机会执行自己的清理代码。也就是不会自动'回收分离进程'，而是整个进程会被强制终止，所有线程（包括分离线程）都会被立即杀死。

• 主线程退出（从 main 返回或调用 exit()） -> 整个进程终止，所有线程（包括分离线程）立即停止，资源由操作系统回收，但不会执行线程的清理代码。
• 主线程调用 pthread_exit() -> 主线程终止，但进程继续运行，直到所有线程（包括分离线程）结束。这样分离线程可以正常完成并执行清理代码。

所以面对这种情况，我们有两种解决方式：

方法 1：使用 pthread_exit()

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, worker, NULL);
    pthread_detach(tid); // 只退出主线程，不终止进程
    pthread_exit(NULL); // 进程继续，分离线程可以运行完成
    return 0;
}

方法 2：让主线程等待（但不阻塞）

int main() {
    pthread_t tid;
    pthread_create(&tid, NULL, worker, NULL);
    pthread_detach(tid); // 主线程做自己的事，但最后等待一下
    sleep(10); // 等待 worker 线程大概完成
    return 0;
}

六、多线程编程的小练习

我们现在使用多线程完成两个文件的拷贝，线程 1 拷贝前一半内容，线程 2 拷贝后一半内容，主线程用于回收两个分支线程的资源。

#include<iostream>
#include<cstdio>
#include<cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/wait.h>
#include<pthread.h>

// 定义要向线程体函数中出入数据的结构体类型
struct Info {
    const char *srcfile; // 要拷贝的原文件
    const char *destfile; // 目标文件
    int start; // 起始位置
    int len; // 要拷贝的长度
};

// 定义获取文件长度的函数
int get_file_len(const char *srcfile, const char *destfile) {
    int sfd, dfd;
    // 以只读的形式打开源文件
    if((sfd = open(srcfile, O_RDONLY)) == -1) {
        perror("open srcfile error");
        return -1;
    }
    // 以只写的形式打开目标文件
    if((dfd = open(destfile, O_RDWR|O_CREAT|O_TRUNC, 0664)) == -1) {
        perror("open destfile error");
        return -1;
    }
    // 获取源文件的长度
    int len = lseek(sfd, 0, SEEK_END);
    close(sfd);
    close(dfd);
    return len;
}

// 定义线程体函数
void *task(void *arg) {
    const char *srcfile = ((struct Info*)arg)->srcfile;
    const char *destfile = ((struct Info*)arg)->destfile;
    int start = ((struct Info*)arg)->start;
    int len = ((struct Info*)arg)->len;
    
    int sfd, dfd;
    if((sfd = open(srcfile, O_RDONLY)) == -1) {
        perror("open srcfile error");
        return NULL;
    }
    if((dfd = open(destfile, O_RDWR)) == -1) {
        perror("open destfile error");
        return NULL;
    }
    
    lseek(sfd, start, SEEK_SET);
    lseek(dfd, start, SEEK_SET);
    
    int ret = 0;
    int count = 0;
    char buf[128] = "";
    
    while(1) {
        ret = read(sfd, buf, sizeof(buf));
        count += ret;
        if(count >= len) {
            write(dfd, buf, ret - (count-len));
            break;
        }
        write(dfd, buf, ret);
    }
    close(dfd);
    close(sfd);
}

int main(int argc, const char *argv[]) {
    if(argc != 3) {
        printf("input file error\n");
        printf("usage:./a.out srcfile destfile\n");
        return -1;
    }
    
    int len = get_file_len(argv[1], argv[2]);
    pthread_t tid1, tid2;
    struct Info buf[2] = {{argv[1], argv[2], 0, len/2}, 
                          {argv[1], argv[2], len/2, len-len/2}};
    
    if(pthread_create(&tid1, NULL, task, &buf[0]) != 0) {
        printf("线程创建失败\n");
        return -1;
    }
    if(pthread_create(&tid2, NULL, task, &buf[1]) != 0) {
        printf("线程创建失败\n");
        return -1;
    }
    
    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);
    printf("拷贝成功\n");
    return 0;
}

结语

文章介绍了多线程的基础概念和各种函数的基本用法。但这只是冰山一角，真正的挑战在于后续的线程同步（Mutex, Condition Variable）、原子操作（Atomic）以及无锁编程。

在后续内容中，我们将深入探讨如何解决竞态条件，揭开互斥锁与同步机制的神秘面纱。