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

【Linux】pthread多线程基础

news 来源：原创 2025/6/4 19:18:00

参考博客：https://blog.csdn.net/Alkaid2000/article/details/128121066

线程概述

  • 与进程类似，线程(thread)是允许应用程序并发执行多个任务的一种机制。一个进程可以包含多个线程。同一个程序中的所有线程均会独立执行相同程序，且共享同一份全局内存区域，其中包括初始化数据段、未初始化数据段、以及堆内存段。（传统意义上的Unix进程只是多线程程序的一个特例，该进程只会包含一个线程

  • 进程是CPU分配资源的最小单位，线程是操作系统调度执行的最小单位

  • 线程是轻量级的进程（LWP：Light Weight Process），在Linux环境下线程的本质仍是进程。

  • 查看指定的进程的LWP号：ps -Lf pid

线程和进程的区别

  • 进程间的信息难以共享。由于除去只读代码段外，父子进程并未共享内存，因此必须采用一些进程间通信方式，在进程间进行信息交换。

  • 调用fork()来创建进程的代价相对较高，即便存在这写时拷贝的这个技术，仍然需要复制诸如内存页表和文件描述符表之类的多种进程属性，这意味着fork()调用在时间上的开销依然不菲。

  • 线程之间能够方便、快速地共享信息。只需将数据复制到共享（全局或堆）变量中即可。创建进程通常要快十倍甚至更多。线程间是共享虚拟地址空间的，无需采用写时复制来复制内存，也无需复制页表。

线程和进程的虚拟地址空间

  • 对于进程，由于写时拷贝的技术，当创建了一个子进程的时候，他会进行写时拷贝，把上面的东西再复制一份。

  • 但是对于线程，由于其共享内存，所以他不会复制这个表，它只会在栈空间以及代码段将其进行分区，把每个线程都在这个段中分配好自己的内存空间。

在这里插入图片描述

线程之间共享的非共享资源

共享资源有如下

进程ID和父进程ID
进程组ID和会话ID
用户ID和用户组ID
文件描述符表
信号处置
文件系统的相关信息：文件权限掩码（umask）、当前工作目录
虚拟地址空间（除栈、.text）
其实以上总的来说是内核的数据。

非共享资源

线程ID
信号掩码
线程特有的数据
error变量
实时调度策略和优先级
栈，本地变量和函数的调用链接信息

NPTL

  • 当Linux最初开发时，在内核中并不能真正使用线程。但是它的确可以通过clone()系统调用将进程作为可调度的实体。这个调用创建了调用进程的一个拷贝，这个拷贝与调度进程共享相同的地址空间。LinuxThreads项目使用这个调用来完全在用户空间模拟对线程的支持。不幸的是，这种方法有一些缺点，尤其是在信号处理、调度和进程间同步等方面都存在问题。另外，这个线程模型也不符合POSIX的要求。

  • 要改进的LinuxThreads，需要内核的支持，并且重写线程库。有两个相互竞争的项目开始来满足这些要求。一个包括IBM的开发人员的团队开展了NGPT（Next-Generation POSIX Threads）项目。同时，Red Hat的一些开发人员开展了NPTL项目。NGPT在2003年中期被放弃了，把这个领域完全留给了NPTL。

  • NPTL，或称为Native POSIX Thread Library，是Linux线程的一个新实现，它克服了LinuxThreads的缺点，同时也复合了POSIX的需求。与LinuxThreads相比，它的性能和稳定性方面都提供了重大的改进。

  • 以查看自己的pthread版本：getconf GNU_LIBPTHREAD_VERSION

在这里插入图片描述

创建线程

使用函数pthread_create(),一般情况下,main函数所在的线程我们称之为主线程（main线程），其余创建的线程称之为子线程。程序中默认只有一个进程，使用fork函数进行调用的话，会产生两个进程；程序中默认只有一个线程，pthread_create()函数调用，2个线程。

  • 在这个函数的说明文档中解释了，线程退出的四个前提：

    1. 当线程主动调用 pthread_exit(3) 时，需传入一个 “退出状态值”（如动态分配的结果、常量等）。其他线程可通过 pthread_join(3) 阻塞等待该线程结束，并获取这个退出状态。

    2. 线程从 start_routine（线程函数）返回时，等价于自动调用 pthread_exit(3)，返回值会被当作退出状态传递。

    3. 其他线程调用 pthread_cancel(3) 向该线程发送 “取消请求”，若线程响应取消（默认允许取消且为延迟取消类型），则会终止。
      注意：
      取消并非 “立即执行”，线程会在 取消点（如 sleep、read 等系统调用，或手动 pthread_testcancel()）响应。
      被取消的线程，pthread_join 获取的退出状态通常是 PTHREAD_CANCELED（即 (void*)-1 ）。

    4. 若进程中任意线程调用 exit(3)，或主线程从 main() 返回，整个进程终止，所有线程（无论是否执行完）都会被强制结束。
      区别线程终止与进程终止：
      线程终止（如 pthread_exit）：仅当前线程结束，其他线程不受影响。
      进程终止（如 exit 或 main 返回）：所有线程一起终止，进程资源被回收。

在这里插入图片描述

void *task(void *arg)
{std::cout << "thread starts ..." << std::endl;std::cout << "value is " << *(static_cast<int *>(arg)) << std::endl;std::cout << "thread ends" << std::endl;std::cout << "pid of task :" << pthread_self() << std::endl;std::cout << "task thread finished" << std::endl;return NULL;
}void test1()
{pthread_t thread_id;int value = 100;int ret = pthread_create(&thread_id, NULL, task, static_cast<void *>(&value));if (ret != 0){const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}usleep(100000);std::cout << "thread_id = " << thread_id << std::endl;std::cout << "pid of test1:" << pthread_self() << std::endl;for (int i = 0; i < 5; ++i){std::cout << "i = " << i << std::endl;}std::cout << "main finished" << std::endl; // 这里不会打印
}
API 详解：pthread_create()
  • 函数原型
int pthread_create(pthread_t *thread,          // 输出参数：线程IDconst pthread_attr_t *attr, // 线程属性，NULL表示默认属性void *(*start_routine) (void *), // 线程函数指针void *arg                   // 传递给线程函数的参数
);
  • 返回值：
    • 成功：返回 0
    • 失败：返回错误码（如 EAGAIN、EINVAL 等）
执行流程
  1. 主线程创建子线程，传递参数&value
  2. 子线程打印信息，包括自己的线程 ID（pthread_self()返回）
  3. 主线程休眠 100ms（usleep(100000)）等待子线程执行
  4. 主线程继续执行后续代码
关键点
  • 线程函数签名：必须是void* (*)(void*)类型
  • 参数传递：通过void*指针传递，需在函数内部转换回原类型
  • 线程 ID：pthread_t类型，用于标识线程，不同系统实现可能不同
  • 错误处理：始终检查pthread_create()的返回值
API 详解：pthread_self

用于获取当前线程的线程 ID，常用来标识、区分不同线程，或在日志打印等场景记录当前执行线程信息。

函数原型
pthread_t pthread_self(void);

参数说明：无输入参数，直接调用即可获取当前线程的线程 ID。

返回值

返回当前线程对应的 pthread_t 类型的线程标识符，不同系统对 pthread_t 具体实现（如是否为整数、结构体等）有差异，但可用于线程相关操作（如比较线程 ID 等 ）。

运行结果
  • 注意需要引入pthread库：-lpthread
    在这里插入图片描述

终止线程

演示线程主动退出的方法，以及pthread_exit()与return的区别

void test2()
{pthread_t thread_id;int value = 100;int ret = pthread_create(&thread_id, NULL, task, (void *)(&value));if (ret != 0){const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}usleep(10000);std::cout << "thread_id = " << thread_id << std::endl;std::cout << "pid of test2 :" << pthread_self() << std::endl;ret = pthread_equal(thread_id, pthread_self());std::cout << "equal : thread_id,pthread_self() :" << ret << std::endl;ret = pthread_equal(thread_id, thread_id);std::cout << "equal : thread_id,thread_id:" << ret << std::endl;pthread_exit(NULL); // 当前线程退出std::cout << "main finished" << std::endl; // 这里不会打印
}
核心代码
pthread_exit(NULL); // 终止当前线程
  • 参数：
    • retval：线程的返回值，可通过pthread_join()获取
  • 说明：
    • 终止当前线程，并将retval传递给等待该线程的其他线程
    • 如果主线程调用pthread_exit()，其他线程仍会继续执行
执行流程
  1. 主线程创建子线程后休眠 10ms
  2. 主线程调用pthread_equal()比较线程 ID
  3. 主线程调用pthread_exit()退出，不影响子线程继续执行
关键点
  • pthread_exit() vs return：
    • return：从线程函数返回，效果与pthread_exit()相同
    • pthread_exit()：可在任何地方调用，终止当前线程
API 详解：pthread_equal

用于比较两个线程 ID 是否属于同一个线程，判断逻辑由系统实现，能帮我们明确不同线程标识是否指向同一实际执行线程。

函数原型
int pthread_equal(pthread_t t1, pthread_t t2);

参数说明：

  • t1：第一个待比较的线程 ID，通过 pthread_create 输出参数或 pthread_self 获取。
  • t2：第二个待比较的线程 ID，来源同 t1 。
返回值
  • 若 t1 和 t2 表示的是同一个线程，返回非 0 值（不同系统实现可能返回具体非零整数，通常可直接用 != 0 判断相等 ）。
  • 若 t1 和 t2 表示不同线程，返回 0 。
运行结果

在这里插入图片描述

连接已终止的线程

  • 当子进程结束需要回收资源时，需要父进程来进行回收，主动的方式是，尽管父进程结束，它也会调用初始化程序来回收这个子进程，被动的方式是，使用wait或者是waitpid函数来等待子进程结束

  • 但是对于线程来说，任意一个线程，都可以回收要结束的线程资源，不一定需要通过父线程。所以为什么需要连接，因为连接后才可以让其资源得到释放，否则会产生僵尸线程

  • 演示如何在线程结束时返回数据，并在主线程中获取该数据。

void *task3(void *arg)
{std::cout << "task3 thread_id:" << pthread_self() << std::endl;int *pValue = (int *)malloc(sizeof(int));*pValue = *static_cast<int *>(arg) + 100;pthread_exit(pValue); // 返回地址，实际作为task3的返回值return NULL;
}void test3()
{pthread_t thread_id;int value = 100;int ret = pthread_create(&thread_id, NULL, task3, (void *)(&value));if (ret != 0){const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}void *retValue = NULL;ret = pthread_join(thread_id, &retValue); // 阻塞if (ret != 0 || retValue == NULL){if (retValue == NULL){std::cerr << "retValue is NULL" << std::endl;return;}const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}std::cout << "retValue = " << *static_cast<int *>(retValue) << std::endl;std::cout << "test3 finished!" << std::endl;free(retValue);
}
核心代码
// 线程函数中
int *pValue = (int *)malloc(sizeof(int));
*pValue = *static_cast<int *>(arg) + 100;
pthread_exit(pValue); // 返回堆上分配的数据// 主线程中
void *retValue = NULL;
pthread_join(thread_id, &retValue); // 获取返回值
std::cout << "retValue = " << *static_cast<int *>(retValue) << std::endl;
free(retValue); // 释放内存
API 详解：pthread_join()

函数原型

int pthread_join(pthread_t thread,   // 要等待的线程IDvoid **retval       // 输出参数：存储线程的返回值
);
  • 返回值：
    • 成功：返回 0
    • 失败：返回错误码（如 EDEADLK、ESRCH 等）
  • 说明：
    • 阻塞当前线程，直到指定线程结束
    • 获取线程的返回值（通过pthread_exit()或return设置）
关键点
  • 内存管理：
    • 线程返回值必须是堆上分配的内存（如malloc/new）
    • 栈上分配的内存（如局部变量）在线程结束后会失效
  • 类型转换：
    • 返回值类型为void*，需转换回实际类型
  • 资源释放：
    • 必须手动释放返回的内存，避免内存泄漏
运行结果

在这里插入图片描述

线程的分离
  • 演示如何将线程设置为分离状态，使其结束后自动释放资源。
void* task4(void *arg)
{std::cout << "task4 started!" << std::endl;sleep(5);std::cout << "task4 finished!" << std::endl;return NULL;
}void test4()
{pthread_t thread_id;int value = 100;int ret = pthread_create(&thread_id, NULL, task4, (void *)(&value));if (ret != 0){const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}ret = pthread_detach(thread_id); // 非阻塞std::cout << "pthread_detach!" << std::endl;if (ret != 0){const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}ret = pthread_join(thread_id, NULL); // 这里会报错if (ret != 0){const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}pthread_exit(NULL);
}
核心代码
pthread_detach(thread_id); // 设置线程为分离状态
API 详解：pthread_detach()

函数原型：

int pthread_detach(pthread_t thread); // 线程ID

  • 返回值：

    • 成功：返回 0
    • 失败：返回错误码（如 EINVAL、ESRCH 等）

  • 说明：

    • 将指定线程设置为分离状态
    • 分离状态的线程结束后，系统自动回收其资源，无需pthread_join()
执行流程
  1. 主线程创建子线程（执行task4，休眠 5 秒）
  2. 主线程调用pthread_detach()将子线程设置为分离状态
  3. 主线程尝试调用pthread_join()等待子线程，失败并输出错误
关键点

  • 分离状态特点：

    • 不能对分离状态的线程调用pthread_join()
    • 适合后台运行且无需返回值的线程（如守护线程）

  • 错误处理：

    • 分离已分离的线程会失败（返回 EINVAL）
    • 对分离状态的线程调用pthread_join()会失败（返回 EINVAL）
运行结果

在这里插入图片描述

线程取消
  • 线程检查是否被取消并按照请求进行动作的一个位置。取消点也是线程检测是否被取消的一个位置。
  • pthreads标准制定了几个取消点，其中包括：
    1. 通过pthread_testcancel调用以编程方式建立线程取消点。
    2. 线程等待pthread_cond_wait或pthread_cond_timewait()中的特定条件。 （错误的程序设计可能会在取消时导致死锁）
    3. 被sigwait()阻塞的函数。
    4. 一些标准的库调用。通常，这些调用包括线程可基于阻塞的函数。

那么这个函数pthread_cancel到底做了什么：

  • 线程默认是可以被取消的。
  • pthread_cancel函数只是给线程发送一个取消请希望可以将线程终止。
  • 对于接收请求的线程来说，只是一种建议。
  • 接收到的取消请求线程可能会马上停止，也可能不会直到遇到一个取消点之后

下面演示如何请求取消一个线程，并处理取消后的状态

void* task4(void *arg)
{std::cout << "task4 started!" << std::endl;sleep(5);std::cout << "task4 finished!" << std::endl;return NULL;
}void test5()
{pthread_t thread_id;int value = 100;int ret = pthread_create(&thread_id, NULL, task4, (void *)(&value));if (ret != 0){const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}sleep(1);std::cout << "thread id before :" << thread_id << std::endl;pthread_cancel(thread_id);std::cout << "thread has benn canceled!" << std::endl;std::cout << "thread id after:" << thread_id << std::endl;void *pValue = NULL;ret = pthread_join(thread_id, &pValue);if (ret != 0){const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}if (pValue == NULL){std::cout << "pValue is NULL" << std::endl;}else{std::cout << "pValue address = " << pValue << std::endl;}pthread_exit(NULL);
}
核心代码
pthread_cancel(thread_id); // 请求取消线程
API 详解：pthread_cancel()

函数原型：

int pthread_cancel(pthread_t thread); // 线程ID
  • 返回值：
    • 成功：返回 0
    • 失败：返回错误码（如 ESRCH）
  • 说明：
    • 发送取消请求给指定线程
    • 线程是否响应取消请求取决于其取消状态和类型
执行流程
  1. 主线程创建子线程（执行task4，休眠 5 秒）
  2. 主线程休眠 1 秒确保子线程已启动
  3. 主线程调用pthread_cancel()请求取消子线程
  4. 主线程调用pthread_join()等待子线程结束并获取返回值
关键点
  • 取消状态与类型：
    • 默认情况下，线程可以响应取消请求（CANCEL_ENABLE）
    • 取消类型分为延迟取消（CANCEL_DEFERRED，默认）和立即取消（CANCEL_ASYNCHRONOUS）
  • 取消点：
    • 线程在某些系统调用（如sleep()、read()）处会检查取消请求
    • 可通过pthread_testcancel()手动设置取消点
  • 返回值：
    • 成功取消的线程通常返回PTHREAD_CANCELED（(void*)-1）
运行结果

在这里插入图片描述

线程属性

对于结构体pthread_attr_t，这个结构体包含了所有的线程属性的信息。所以我们需要对这个结构体进行操作，才可以更改其进程属性，其实无非就是开辟一块内存，然后存放其相应的信息，主要涉及的函数有如下：

  • 通过一下命令可以查看对应的设置属性函数
man -k pthread_attr_

在这里插入图片描述

  • 演示如何使用线程属性对象（pthread_attr_t）设置线程的分离状态和栈大小。
void* task4(void *arg)
{std::cout << "task4 started!" << std::endl;sleep(5);std::cout << "task4 finished!" << std::endl;return NULL;
}void test6(){pthread_t thread_id;pthread_attr_t attr;pthread_attr_init(&attr);pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED); //设置线程启动属性：detachint value = 100;int ret = pthread_create(&thread_id, &attr, task4, (void *)(&value));std::cout << "detach not blocking !" << std::endl;if (ret != 0){const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}size_t size = 0;ret = pthread_attr_getstacksize(&attr,&size);std::cout << "pthread get statck size: " << size << std::endl;int state = 0;ret = pthread_attr_getdetachstate(&attr,&state);std::cout << "pthread detach state :" << state << std::endl;sleep(10);ret = pthread_join(thread_id, NULL); //无法join了if (ret != 0){const char *error = strerror(ret);std::cout << "error: " << error << std::endl;return;}pthread_attr_destroy(&attr);}
核心代码
pthread_attr_t attr;
pthread_attr_init(&attr); // 初始化属性对象
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); // 设置为分离状态// 创建线程时使用属性对象
pthread_create(&thread_id, &attr, task4, (void *)(&value));// 获取属性信息
size_t size = 0;
pthread_attr_getstacksize(&attr, &size); // 获取栈大小int state = 0;
pthread_attr_getdetachstate(&attr, &state); // 获取分离状态
API 详解：线程属性函数

初始化与销毁：

int pthread_attr_init(pthread_attr_t *attr); // 初始化属性对象
int pthread_attr_destroy(pthread_attr_t *attr); // 销毁属性对象

设置分离状态

int pthread_attr_setdetachstate(pthread_attr_t *attr,       // 属性对象int detachstate             // 分离状态：PTHREAD_CREATE_DETACHED 或 PTHREAD_CREATE_JOINABLE
);
int pthread_attr_getdetachstate(pthread_attr_t *attr,       // 属性对象int *detachstate            // 输出参数：当前分离状态
);

设置栈大小

int pthread_attr_setstacksize(pthread_attr_t *attr,       // 属性对象size_t stacksize            // 栈大小（字节）
);
int pthread_attr_getstacksize(pthread_attr_t *attr,       // 属性对象size_t *stacksize           // 输出参数：当前栈大小
);
执行流程
  1. 初始化线程属性对象并设置为分离状态
  2. 使用该属性创建线程
  3. 获取并打印线程的栈大小和分离状态
  4. 主线程休眠 10 秒，等待子线程执行（虽然子线程是分离的）
  5. 尝试pthread_join()已分离的线程，失败并输出错误
关键点
  • 属性对象生命周期：
    • 使用前必须初始化（pthread_attr_init()）
    • 使用后必须销毁（pthread_attr_destroy()）
  • 分离状态的两种设置方式：
    1. 创建线程后调用pthread_detach()
    2. 创建线程前通过属性对象设置（PTHREAD_CREATE_DETACHED）
  • 栈大小：
    • 默认栈大小由系统决定（通常为几 MB）
    • 可通过pthread_attr_setstacksize()调整，需注意栈溢出风险
运行结果

在这里插入图片描述

更多资料：https://github.com/0voice

相关文章：

  • Java集合初始化：Lists.newArrayList vs new ArrayList()
  • PART 6 树莓派小车+QT （TCP控制）
  • 开发的几种格式,TCP的十个重要机制
  • Figma 与 Cursor 深度集成的完整解决方案
  • 从【0-1的HTML】第1篇：HTML简介
  • SQL 执行顺序详解
  • PostgreSQL pgrowlocks 扩展
  • LeetCode 高频 SQL 50 题（基础版） 之 【高级查询和连接】· 上
  • SQL： 窗口滑动（Sliding Window）
  • C++前缀和介绍
  • MyBatisPlus--条件构造器及自定义SQL详解
  • Linux(信号)
  • PostgreSQL的扩展 insert_username
  • 数据库系统概论（十四）详细讲解SQL中空值的处理
  • 连接天际，守护通信—5G航天时代的电流守卫与浪涌盾牌
  • Caliper压力测试
  • vue · 路由传参query和params
  • Codeforces Round 1028 (Div. 2)(A-D)
  • 深入理解 Linux 文件系统与日志文件分析
  • C++ list代码练习、set基础概念、set对象创建、set大小操作
  • 自己有了域名 怎么做网站/企业seo顾问服务
  • 外贸网站友情链接/做网页设计的软件
  • 吉林省软环境建设网站/东莞seo建站如何推广
  • 帮别人做钓鱼网站吗/小红书关键词排名
  • wordpress4.9 多站点/南宁网站建设及推广
  • 做网站填写主要品牌怎么填写/武汉关键词排名工具