【Linux学习笔记】线程概念和控制(三)
🔥个人主页 ：大白的编程日记
🔥专栏：Linux学习笔记
文章目录
- 【Linux学习笔记】线程概念和控制(三)
- 1.线程终止
-
- [1.1 pthread_exit函数](#1.1 pthread_exit函数)
- [1.2 pthread_cancel函数](#1.2 pthread_cancel函数)
- [2 线程等待](#2 线程等待)
- [3 分离线程](#3 分离线程)
- [4. 线程ID及进程地址空间布局](#4. 线程ID及进程地址空间布局)
-
- [4.1 用户线程和LWP联动](#4.1 用户线程和LWP联动)
-
- [4.2 内核源代码](#4.2 内核源代码)
- [4.3 Mmap文件映射&线程栈](#4.3 Mmap文件映射&线程栈)
- [6-2 线程栈](#6-2 线程栈)
- [5 线程封装](#5 线程封装)
前言
哈喽，各位小伙伴大家好!上期我们讲了线程概念和控制(二)) 今天我们讲的是线程概念和控制(三)。话不多说，我们进入正题！向大厂冲锋！
1.线程终止
如果需要只终止某个线程而不终止整个进程,可以有三种方法:
- 从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。
- 线程可以调用
pthread_exit终止自己。 - 一个线程可以调用
pthread_cancel终止同一进程中的另一个线程。
1.1 pthread_exit函数
功能：线程退出
原型：
c
void pthread_exit(void *value_ptr);参数：
- value_ptr:value_ptr不要指向一个局部变量。
返回值：
- 无返回值，跟进程一样，线程结束的时候无法回到它的调用者（自身）
需要注意,pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的,不能在线程函数的栈上分配,因为当其它线程得到这个返回指针时线程函数已经退出了。
1.2 pthread_cancel函数
功能：取消一个执行中的线程
原型：
c
int pthread_cancel(pthread_t thread);参数：thread:线程ID
返回值：成功返回0；失败返回错误码
2 线程等待
为什么需要线程等待？
- 已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
- 创建新的线程不会复⽤刚才退出线程的地址空间。
c
功能：等待线程结束
原型
int pthread_join(pthread_t thread, void **value_ptr);
参数:
thread:线程ID
value_ptr:它指向⼀个指针，后者指向线程的返回值
返回值：成功返回0；失败返回错误码调用该函数的线程将挂起等待,直到id为thread的线程终止。thread线程以不同的方法终止,通过pthread_join得到的终止状态是不同的，总结如下:
- 如果thread线程通过
return返回,value_ptr所指向的单元里存放的是thread线程函数的返回值。 - 如果thread线程被别的线程调用
pthread_cancel异常终结,value_ptr所指向的单元里存放的是常数PTHREAD_CANCELED。 - 如果thread线程是自己调用
pthread_exit终止自己的,value_ptr所指向的单元里存放的是传给pthread_exit的参数。 - 如果对thread线程的终止状态不感兴趣,可以传NULL给value_ptr参数。
3 分离线程
- 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
- 如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。
c
int pthread_detach(pthread_t thread);可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离：
c
pthread_detach(pthread_self());joinable和分离是冲突的，一个线程不能既是joinable又是分离的。
c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
void *thread_run( void * arg ){
pthread_detach(pthread_self());
printf("%s\n", (char*)arg);
return NULL;
}
int main( void ){
pthread_t tid;
if ( pthread_create(&tid, NULL, thread_run, "thread1 run....") != 0 ){
printf("create thread error\n");
return 1;
}
int ret = 0;
sleep(1);//很重要，要让线程先分离，再等待
if ( pthread_join(tid, NULL ) == 0 ){
printf("pthread wait success\n");
ret = 0;
} else {
printf("pthread wait failed\n");
ret = 1;
}
return ret;
}
4. 线程ID及进程地址空间布局
pthread_create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面说的线程ID不是一回事。- 前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。
pthread_create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。- 线程库NPTL提供了
pthread_self函数，可以获得线程自身的ID：
c
pthread_t pthread_self(void);pthread_t 到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。
4.1 用户线程和LWP联动
4.2 内核源代码
4.3 Mmap文件映射&线程栈
- 允许用户空间程序将文件或设备的内容直接映射到进程的虚拟地址空间中。通过
mmap，程序可以高效地访问文件数据，而无需通过传统的 read 或 write 系统调用进行数据的复制。 mmap还可以用于实现共享内存，允许不同进程间共享数据。
6-2 线程栈
虽然 Linux 将线程和进程不加区分的统一到了
task_struct，但是对待其地址空间的 stack 还是有些区别的。
-
对于 Linux 进程或者说主线程，简单理解就是 main 函数的栈空间，在 fork 的时候，实际上就是复制了父亲的 stack 空间地址，然后写时拷贝(cow)以及动态增长。如果扩充超出该上限则抛出会报段错误（发送段错误信号给该进程）。进程栈是唯一可以访问未映射页而不一定会发生段错误------超出扩充上限才报。
-
然而对于主线程生成的子线程而言，其 stack 将不再是向下生长的，而是事先固定下来的。线程栈一般是调用 glibc/uclibc 等的 pthread 库接口 pthread_create 创建的线程，在文件映射区（或称之为共享区）。其中使用 mmap 系统调用，这个可以从 glibc 的
nptl/allocatestack.c中的allocate_stack函数中看到：
c
mem = mmap (NULL, size, prot,
MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);此调用中的 size 参数的获取很是复杂，你可以手工传入 stack 的大小，也可以使用默认的，一般而言就是默认的 8M。这些都不重要，重要的是，这种 stack 不能动态增长，一旦用尽就没了，这是和生成进程的 fork 不同的地方。在 glibc 中通过 mmap 得到了 stack 之后，底层将调用 sys_clone 系统调用：
cpp
int sys_clone(struct pt_regs *regs)
{
unsigned long clone_flags;
unsigned long newsp;
int __user *parent_tidptr, *child_tidptr;
clone_flags = regs->bx;
// 获取了 mmap 得到的线程的 stack 指针
newsp = regs->cx;
child_tidptr = (int __user *)regs->dx;
parent_tidptr = (int __user *)regs->di;
if (!newsp)
newsp = regs->sp;
return do_fork(clone_flags, newsp, regs, 0, parent_tidptr,
child_tidptr);
}因此，对于子线程的 stack，它其实是在进程的地址空间中
mmap出来的一块内存区域，原则上是线程私有的，但是同一个进程的所有线程生成的时候，是会浅拷贝生成者的
task_struct的很多字段，如果愿意，其它线程也还是可以访问到的，一定要注意。
5 线程封装
cpp
#ifndef _THREAD_H_
#define _THREAD_H_
#include <iostream>
#include <string>
#include <pthread.h>
#include <cstdint> // 或者 #include <cstdint.h>
#include <cstdio>
#include <cstring>
#include <functional>
using namespace std;
namespace ThreadModlue
{
using func_t = function<void()>;
static uint32_t number = 1;
class Thread
{
public:
Thread(func_t func)
: _tid(0),
_isdetach(false),
_isrunning(false),
res(nullptr),
_func(func)
{
_name = "thread-" + std::to_string(number++);
}
//分离线程
void EnableDetach()
{
std::cout << "线程被分离了" << std::endl;
_isdetach = true;
}
void EnableRunning()
{
_isrunning = true;
}
//分离线程·
void Detach()
{
if (_isdetach)
return;
if (_isrunning)
pthread_detach(_tid);
EnableDetach();
}
//为了参数匹配static取消this指针 通过参数传递this指针
static void* routine(void* args)
{
Thread* self=static_cast<Thread*>(args);
self->EnableRunning();
if(self->_isdetach)
{
self->Detach();
}
pthread_setname_np(self->_tid, self->_name.c_str());
self->_func();//执行任务
return nullptr;
}
//等待线程
void Join()
{
if (_isdetach)
{
cout << "线程已经分离 无需join!" << endl;
return;
}
int n = pthread_join(_tid, nullptr);
if (n == 0)
{
cout << "join successd!" << endl;
}
else
{
cout << "join error" << strerror(n) << endl;
}
}
//停止线程
bool Stop()
{
if (_isrunning)
{
int n = pthread_cancel(_tid);
if (n == 0)
{
cout << "thread stop success!" << endl;
return 1;
}
else
{
cout << "stop error" << strerror(n) << endl;
return 0;
}
}
return 0;
}
//启动线程
bool Start()
{
if (_isrunning)
return 0;
int n = pthread_create(&_tid, nullptr, routine, this);
if (n == 0)
{
cout << "thread create success!" << endl;
return 1;
}
else
{
cout << "create error" << strerror(n) << endl;
return 0;
}
}
private:
pthread_t _tid;
std::string _name;
bool _isdetach;
bool _isrunning;
void *res;
func_t _func;
};
}
#endif
所以这里我们分离线程后 就无需join了！
后言
这就是线程概念和控制(三)。大家自己好好消化！今天就分享到这！ 感谢各位的耐心垂阅！咱们下期见！拜拜~
