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

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

向线程体中传递单个数据

**注意：我们传过来的参数必须要进行强转，*当然此处若不想添加参数，就直接填 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);
    //1314
}

/**************主程序********************************/
int main(int argc, const char *argv[]){
    pthread_t tid = -1; //用于存储线程号的变量
    int num = 520;
    if(pthread_create(&tid, NULL, task, &num) != 0){
        //参数 2：表示让系统使用默认属性创建一个线程
        //参数 3：线程体函数名
        //参数 4：表示向线程体中传递的数据
        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){
        //参数 2：表示让系统使用默认属性创建一个线程
        //参数 3：线程体函数名
        //参数 4：表示向线程体中传递的数据
        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()); //2、调用函数，输出当前线程的线程号
    sleep(3); //3、退出线程
    pthread_exit(NULL);
}

/**********************主程序****************************/
int main() {
    //1、定义一个线程号变量
    pthread_t tid = -1;
    //创建一个线程
    if(pthread_create(&tid, NULL, task, NULL) != 0) {
        printf("pthread_create error\n");
        return -1;
    }
    printf("主线程，tid = %#x\n", tid);
    //4、回收分支线程的资源
    //pthread_join(tid, NULL); //前 3 秒，主线程处于休眠等待分支线程的结束
    //分支线程处于休眠状态
    //将线程设置成分离态 (非阻塞)
    pthread_detach(tid);
    sleep(5); // while(1); //防止主线程结束
    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
    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 中
        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）以及无锁编程。

在下一篇博客中，我们将深入探讨如何解决竞态条件，揭开互斥锁与同步机制的神秘面纱。