【Linux】线程控制
一，使用介绍
1. POSIX线程库
对于Linux内核而言，没有线程，只有轻量级进程。但是对于用户而言，需要有线程。
所以，pthread（用户态库）就对Linux的轻量级进程进行了封装，为用户提供线程接口（而把Linux内部的轻量级进程隐藏起来）
头文件：<pthread.h>
编译时要连接对应的库：-lpthread（但是：现合并到libc，不用显式链接也能跑）
某些语言自己的线程库，本质上都是对OS的线程库操作的封装。如，C++的线程库，他会封装Linux的线程库pthread，也会封装Windows的线程库，然后再根据自己的运行环境，通过条件编译选择对应的实现版本。
2. 创建线程
int pthread_create(pthread_t *thread, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg);
功能：创建一个新线程，让新线程执行对应的函数
参数
thread：返回线程ID（这是属于语言层的线程ID，内核并不认识）
attr：设置线程的属性，为NULL表示使用默认属性
start_routine：函数地址，线程启动后要执行的函数
arg：传给线程启动函数的参数
返回值：
成功返回0
失败返回错误码（pthreads函数出错时不会设置全局变量errno）
3. 结束线程
结束进程有三种方法：
return：最推荐（不能return局部变量）
pthread_exit(void *value_ptr)：终止自己，不会影响其他线程（等效于return）
value_ptr返回值，不能是局部变量（这和后续获取返回值有关，下文会讲述如何获取返回值）
pthread_ cancel(pthread_t thread)：取消其他线程（注意，只能取消已经启动的线程）
注意：不能使用exit()：该函数为整个进程退出
4. 等待线程
和进程一样，主线程需要等待线程（其实目的也一样，后续会讲到对应的结构更好理解）
int pthread_join(pthread_t thread, void **value_ptr);
功能：等待线程（该等待只有阻塞等待）
参数
thread：线程ID
value_ptr：它指向⼀个指针，后者指向线程的返回值
返回值：
成功返回0
失败返回错误码
5. 分离线程
默认情况下，新创建的线程是joinable的（即：需要等待），如果我们不关心线程的退出信息，可以进行分离线程，让线程退出时，自己释放资源。
int pthread_detach(pthread_t thread)
功能，分离线程（可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离）
参数
thread：线程ID
分离以后再join就会出错
二，使用示例
#include <iostream>
#include <string>
#include <unistd.h>
#include <pthread.h>
using namespace std;
void *thread(void *num) // 要求返回值和参数类型都是 void*
{
cout << "我是线程 " << *((int *)num) << " 我的ID是: " << pthread_self() << endl;
sleep(5);
cout << "线程 " << *((int *)num) << " 退出" << endl;
return num;
}
int main()
{
pthread_t threads_id[5];
for (int i = 1; i <= 5; i++)
{
pthread_t thread_id;
pthread_create(&threads_id[i - 1], nullptr, thread, (void *)&i);
pthread_detach(threads_id[i - 1]); // 线程分离
sleep(2);
}
void* ret = nullptr;
// 一个个等
// for(int i = 0; i <= 4; i++)
// {
// pthread_join(threads_id[i], &ret);
// cout << "等到子线程" << *(int*)ret << endl;
// }
cout << "所有子线程都等到了，主线程退出" << endl;
return 0;
}
通过：ps -aL我们可以看到线程的状态
展示部分（一边创建的时候，可能会有一边退出的）
LWP：轻量级进程的编号，CPU的调度单位（内核层用来标识轻量级进程）
三，用户层与内核层的“线程”
对于Linux，线程是用户态的概念，通过封装Linux的轻量化进程到pthread库实现
pthread库底层通过封装系统调用clone来与内核交互
首先，pthread是一个库，也是一个文件，它会通过mmap映射到进程地址空间上。
其次，库中每个线程有TCB（语言层），并用链表或者其他数据结构组织。（类似PCB）
在这个TCB里，主要有三个重要的结构：
struct pthread：（线程控制块的核心）其中包括：用户层属性 + 内核映射 …
线程局部存储：用来存储线程希望“专有”的变量（只能存储内置类型和部分指针）
线程独立的栈结构：存放该线程执行时产生的临时数据
1. 原码解析
glibc-2.4中pthread源码相关内容（只看重点）:
// 线程的属性（用 struct pthread_attr 记录）
const struct pthread_attr *iattr = (struct pthread_attr *)attr;
// 指向struct pthread的起始地址（虚拟的）
// 这玩意就是我们调用pthread_creat 得到的线程ID
struct pthread *pd = NULL;
// 根据 iattr 中的栈属性（如 stacksize）分配线程栈
// 同时分配并初始化 struct pthread 结构体
// pd 存储返回新分配的 TCB 地址（同时也就是 struct pthread的起始地址）
int err = ALLOCATE_STACK(iattr, &pd);
// 记录线程要执行的函数的入口和参数
pd->start_routine = start_routine;
pd->arg = arg;
// 把线程ID存入newthread，newthread指向线程的 TCB
*newthread = (pthread_t)pd;
// 检查是否分离
bool is_detached = IS_DETACHED(pd);
// 创建一个进程，内部封装 clone
err = create_thread(pd, iattr, STACK_VARIABLES_ARGS);
struct pthread_attr
用于用户在创建线程前配置线程属性的结构体（如栈大小、分离状态等）
属于用户空间的 API，用户可以直接操作
只在调用 pthread_create() 时起作用
关键属性：
...
int flags; // 存储线程的各种属性标志位，其中包括分离状态
/* Stack handling. */
void *stackaddr; // 栈的起始地址
size_t stacksize; // 栈的大小
...
struct pthread
TCB的核心，（类似文件的FILE结构体）
// 线程的 LWP（CPU的调度单位）
pid_t tid;
// 线程所属的进程的PID
pid_t pid;
// 存放进程函数退出的返回值
void *result;
// 用户指定的线程函数入口和参数
void *(*start_routine) (void *);
void *arg;
// 线程自己的栈和⼤⼩
void *stackblock; // 指向栈
size_t stackblock_size;
当我们创建一个线程，线程通过用户提供的函数入口start_routine去执行对应的代码
产生的临时数据存放在用户提供的独立的栈中
线程运行完毕，返回值就是void*， 返回值会被拷贝到result
线程退出后，结构体本身和线程栈不会立即释放
所以我们要用 pthread_join 等待，并且 join 获取线程退出信息时，就是读取该结构体
create_thread
// 封装的clone
...
int res = do_clone(pd, attr, clone_flags, start_thread,
STACK_VARIABLES_ARGS, stopped);
do_clone
...
if (ARCH_CLONE(fct, STACK_VARIABLES_ARGS, clone_flags,
pd, &pd->tid, TLS_VALUE, &pd->tid) == -1)
ARCH_CLONE __clone
...
movl $SYS_ify(clone),%eax // 获取系统调⽤号
...
syscall // 陷⼊内核(x86_32是int 80)，内核创建轻量级进程
...
所以，在创建线程的时候，其实就是在pthread库内部，创建好描述线程的结构体对象struct pthread，填充属性（用户层）
struct pthread通常在线程栈的顶部高地址端（也就是在TCB的前面）
然后由系统创建好线程栈（通过 mmap分配）
调用clone，让内核创建轻量级进程，并传入回调函数和参数（系统层）
其实，库提供的无非就是未来操作线程的API，通过属性设置线程的优先级之类，而真正调度的过程，还是内核来的
2. 线程栈
我们在传递线程栈的起始地址的时候，传递的是高地址，因为线程栈在主进程的堆上开辟，堆向下增长
线程栈的空间创建好以后就是固定的，大小为页大小的整数倍
它其实是在进程的地址空间中map出来的⼀块内存区域
3. 线程局部存储
如果我们定义一个全局变量，然后有两个线程，线程a对变量进行修改，线程b读取，则b是能读到a的修改的。（此时变量是存储在进程的已初始化数据区的）
但是如果我们在变量加__thread，则可以引导编译器：把变量的存储位置改到线程的局部存储区。
这时候，a对变量的修改，b就看不到（虽然两进程访问的变量名相同，但是访问的实际是不同的虚拟地址）
注意：线程局部存储只能存储内置类型和部分指针
四，模拟封装线程库
mythread.hpp
#pragma once
#include <iostream>
#include <pthread.h>
#include <functional>
#include <stdlib.h>
#include <string>
namespace tr
{
int cnt = 1; // 设计一个计数器
class Mythread
{
private:
static void *start_routine(void *obj) // obj 是 this指针
{
// 类内成员函数有this指针，无法传入pthread_create
// 所以设计static成员函数（接受this），来回调要传入的方法
Mythread *self = static_cast<Mythread *>(obj);
// 在这里往线程局部存储存入_name，以便在类外能够获取
pthread_setname_np(self->_tid, self->_name.c_str());
self->_func(); // 回调
return nullptr;
}
public:
using func_t = std::function<void()>; // 接受一个无参无返回值的函数的回调
Mythread(bool enablejoin, func_t func) // 构造函数是在主线程执行的
: _enablejoin(enablejoin), _running(true), _func(func)
{
int ret = pthread_create(&_tid, nullptr, start_routine, this);
if (ret != 0)
{
perror("pthread_create");
exit(EXIT_FAILURE);
}
else
{
_name = "thread " + std::to_string(cnt++);
std::cout << _name << "创建成功" << std::endl;
}
if (!_enablejoin)
{
pthread_detach(_tid);
}
}
void Detach()
{
if (_enablejoin)
{
pthread_detach(_tid);
}
_enablejoin = false;
}
void Cancel()
{
if (_running)
{
pthread_cancel(_tid);
}
_running = false;
_enablejoin = false;
}
void Join() // 只能 join 自己
{
if (_enablejoin)
{
int ret = pthread_join(_tid, nullptr);
if (ret != 0)
{
perror("pthread_join");
exit(EXIT_FAILURE);
}
else
{
std::cout << _name << "被成功join" << std::endl;
}
}
else
{
std::cout << _name << "已经分离, 不能被join" << std::endl;
}
}
~Mythread()
{
}
private:
pthread_t _tid; // 用户线程 ID
bool _enablejoin;
bool _running;
std::string _name;
func_t _func; // 该线程要执行的函数
};
}
Main.cpp
#include "MyThread.hpp"
#include <unistd.h>
void func1()
{
sleep(1); // 等一下名字设置
char name[256];
pthread_getname_np(pthread_self(), name, sizeof(name));
std::cout << name << "任务执行完毕" << std::endl;
}
void func2()
{
sleep(1);
char name[256];
pthread_getname_np(pthread_self(), name, sizeof(name));
std::cout << name << "任务执行完毕" << std::endl;
}
int main()
{
pthread_setname_np(pthread_self(), "main_thread");
tr::Mythread t1(true, func1);
tr::Mythread t2(true, func2);
// t1.Detach();
// t1.Cancel();
t1.Join();
t2.Join();
sleep(3); // 让主线程慢一点退出
std::cout << "执行完毕" << std::endl;
return 0;
}
————————————————
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
原文链接：https://blog.csdn.net/tan_run/article/details/148240506
