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

【Linux】线程控制

news 来源：原创 2025/8/21 14:14:43

一、原生线程库：

二、线程控制：

1、线程创建：

2、线程等待：

自定义类型的接收对象：

编辑

3、线程终止：

pthread_exit：

pthread_cancel:

4、线程ID：

线程库的底层原理

三、线程栈：

创建多线程：

栈区变量：

局部性存储：

拿到别的线程执行流数据：

四、线程分离：

一、原生线程库：

在编译代码的时候，需要新加选项-lpthread（在部分环境下是不用加的，如果出现链接错误就加上，没有就不用加），因为要使用pthread的原生线程库

什么是原生线程库：

我们知道，在Linux中是没有真正意义上线程的概念的，只有轻量级进程的概念，

所以Linux工程师在系统层和用户层之间封装了原生线程库方便用户进行使用

在Linux中，原生线程库也是pthread库，在使用的时候包含即可

二、线程控制：

1、线程创建：

pthread_t：这其实就是无符号长整型：unsigned long int

接下来看看参数：

参数1：pthread_t* thread

这是一个输出型参数，表示线程的tid

参数2：设置线程属性，一般直接nullptr即可

参数3：这是一个函数指针，这是一个很重要的参数，发现这个函数返回值是void*，参数也是void*，这是一个回调函数，当线程启动的时候会自动回调此函数

参数4：这是void*类型的，就是线程启动时，传递给上述函数的形参

返回值：成功返回0，失败返回一个错误码

void* newthread(void* argc)
{while(1){cout << "我是新线程，我正在运行，pid : " << getpid() <<endl;sleep(1);}return nullptr;
}int main()
{pthread_t tid;pthread_create(&tid,nullptr,newthread,nullptr);    sleep(1);while(1){cout << "我是主线程，我正在运行，pid : " << getpid() << endl;sleep(1);}return 0;
}

如上，写一段线程小代码，运行后：

如上，可以发现：这两个线程的pid也就是进程id是一样的，也就证明了线程是进程内部的分支

可以通过指令ps -aL来观察线程的属性

如上，可以发现每个线程有其独特的LWP，这就类似于进程的pid，CPU在调度线程的时候是通过LWP来进行调度的

如上，仔细观察还会发现有一个线程的LWP和PID是相等的，此时这个线程就叫做主线程

多线程错误：

同时对于这些线程如果一个线程发生了错误，那么所有共享一个进程的线程都会退出

如下，我们修改代码为存在除零错误

那么当主线程出现错误的时候，尽管别的进程没有错误，但是仍然会退出

同样的，向一个线程发送终止信号，其他线程也会被终止：

全局变量：

同样的，线程也共享者全局变量区：

如上，当在主线程中进行num的++，在新线程中打印出num的值也会++，所以线程间通信是比较方便的

2、线程等待：

线程和进程是差不多的，父进程需要等待子进程，防止子进程僵尸
主线程也需要等待新线程，在原生线程库中，封装了一个接口：pthread_join

参数1：thread：这是待等待线程的ID

参数2：retval：输出型参数，用于获取新线程的返回值，

返回值：成功返回0，失败返回错误码

void* newthread(void* arr)
{const char* name = (const char*)arr;int cnt = 5;while(1){cout << name << "new thread : pid : " << getpid() << endl;sleep(1);cnt--;if(cnt == 0) break;}return (void*)11;
}int main()
{pthread_t tid;pthread_create(&tid,nullptr,newthread,(void*)"Thread 1 ");sleep(7);void* retval;pthread_join(tid,&retval);cout << "ret : " << (long)retval << endl;cout << "main quit success ..." << endl;return 0;
}

自定义类型的接收对象：

#include <iostream>
#include <unistd.h>
#include <pthread.h>
#include <string>using namespace std;class Request
{
public:Request(int start,int end,const string& threadname):_start(start),_end(end),_threadname(threadname){}public:int _start;int _end;string _threadname;
};class Response
{
public:Response(int retval,int retcode):_retval(retval),_retcode(retcode){}
public:int _retval;int _retcode;
};void* sumcount(void* argc)
{Request* rq = static_cast<Request*>(argc);Response* rsp = new Response(0,0);for(int i = rq->_start;i <= rq->_end;i++){rsp->_retval += i;}delete rq;return rsp;
}int main()
{pthread_t tid;Request* rq = new Request(1,100,"mythread");pthread_create(&tid,nullptr,sumcount,rq);void* ret;pthread_join(tid,&ret);Response *rsp = static_cast<Response*>(ret);cout << "rsp->result: " << rsp->_retval << ", exitcode: " << rsp->_retcode << endl;delete rsp;return 0;
}

如上，这就是计算两个数之间的和

上述有两个地方要注意：

1、在主函数中pthread_create中的第三个参数不用强转，而之前的字符串需要强转，这是因为之前的字符串默认是const char* 的，强制转换成void*这样可以避免权限放大

而这里自定义类型不用强转，尽管类型不同，这是因为void*类型的指针可以接受任意类型的指针

2、里面运用到了static_cast，这是C++引入的，比()强转更安全，因为：会在编译时进行类型检查，如果转换不合法（例如无关类型之间的转换），编译器会报错，而()强制类型转换，基本上都是可以转换的

3、线程终止：

pthread_exit：

将一个线程终止有许多方法，比如发信号，exit等等

如果在代码中调用exit，这是将进程退出，那么就会导致所有线程都会退出，这显然是不对的，
那么在原生线程库中就封装了接口：pthread_exit

参数retval：这就是类似于exit中的参数，退出码，返回值

这里的retval和pthread_join里的retval形参名字怎么是一样的呢？

首先我们要知道，主线程和创建出来的新线程是在不同的栈帧中的，那么想要远程修改就需要赋值传地址

如下，将新线程中的return可以改为pthread_exit()，这样优雅多了

pthread_cancel:

参数：指的是取消哪一个线程，并且退出的线程，退出码为-1

返回值：成功返回0，失败返回错误码

void* newthread(void* arr)
{const char* name = (const char*)arr;int cnt = 5;while(1){cout << name << "new thread : pid : " << getpid() << endl;sleep(1);cnt--;if(cnt == 0) break;}pthread_exit((void*)11);
}int main()
{pthread_t tid;pthread_create(&tid,nullptr,newthread,(void*)"Thread 1 ");sleep(2);pthread_cancel(tid);void* retval;pthread_join(tid,&retval);cout << "retval : " << (long)retval << endl;cout << "main quit success ..." << endl;return 0;
}

如上，我们不应该取消成功后返回0吗，这里为什么是-1呢？

注意：这里的-1是指的是取消线程的退出码，而不是pthread_cancel的退出码

4、线程ID：

如上，这个接口是获取当前线程的tid

void* newthread(void* arr)
{const char* name = (const char*)arr;int cnt = 5;while(1){cout << name << "new thread : pid : " << getpid() << " tid : " << pthread_self() << endl;sleep(1);cnt--;if(cnt == 0) break;}pthread_exit((void*)11);
}int main()
{pthread_t tid;pthread_create(&tid,nullptr,newthread,(void*)"Thread 1 ");cout <<"主线程的tid : " << pthread_self() << endl; cout <<"创建的新线程的tid : " << tid << endl;void* retval;pthread_join(tid,&retval);cout << "retval : " << (long)retval << endl;cout << "main quit success ..." << endl;return 0;
}

如上，发现这个tid和新线程中的pthread_self是一样的

但是这个tid和我们ps -aL中的LWP是不一样的，本来二者也都是不一样的，因为LWP是操作系统层面的概念，操作系统自己知道即可，我们用户只关心tid

这个线程ID到底是什么东西呢？和tid是不是同一个东西呢？

线程库的底层原理

我们先理解理解如下的图

1、在Linux中是没有线程的概念的，只有轻量级进程的概念

2、所以我们在Linux中的线程的概念是库给我们维护的------所以线程库要维护线程的概念(这是用户关心的，比如说线程的tid，线程的时间片有没有到等)又因为这个线程在底层是维护的轻量级进程的执行流，是不用维护线程的执行流的

3、所以这个原生线程库要不要加载到内存中?------当然要，不然怎么用------那么加载到哪里?----- 加载到内存中，通过页表把pthread库映射到我们的共享区

4、我们每创建一个线程，都要在线程库中创建一个线程控制块供用户维护，
这个线程控制块对上提供信息如独立栈在哪？线程ID是什么，回调函数在哪等等，
更重要的是对下提供该线程的LWP指向底层的哪个轻量级进程的执行流

如上，这样就能够很好的管理我们的线程了，当想要拿到对应的线程ID时，直接访问这个描述好的结构体里直接拿就行了
而tid是一个地址：是每一个线程库级别的tcb起始地址，

为什么要以每个tcb的起始地址作为tid呢？

1、它里面存放的是地址
2、它是在用户空间的
3、是虚拟地址，可以直接访问的

三、线程栈：

每一个线程在其运行时有独立的栈结构
因为每一个线程有其独特的调用链
也就是必须有其调用链对应的栈帧结构
这个栈结构会保存任何一个执行流在其运行中的所有临时变量比如压栈的形参，返回值等等

其中主线程直接用地址空间结构中的栈结构即可
其他被主线成pthread_create创建的都是轻量级进程，这些线程用的不是地址空间的栈，而是用的是线程库中独立的栈结构

其做法是首先在pthread.so里面创建创建对应的描述这个线程的线程控制块tcb，这个tcb的起始地址就作为这个线程的tid，里面有一块默认大小的空间，这就是线程栈

当在内核中创建执行流，就是在库里面调用clone()接口，然后把线程执行的方法，已经刚刚创建的线程栈作为第一第二参数传递给clone()，这个函数不是我们使用的，Linux程序员已经将这个函数封装起来了，我们只需要使用这个函数封装后的接口如pthread_create，pthread_join等等

接下来用代码来理解理解：

创建多线程：

首先，我们用一个vector数组来存储多线程的tid，然后定义一个类对象和10进制转16进制的函数，接着就可以实现多线程的实现了

#include <iostream>
#include <string>
#include <vector>
#include <pthread.h>
#include <unistd.h>using namespace std;#define N 3class threadDate
{
public:threadDate(int number){_threadname = "thread-" + to_string(number); // thread-0}public:string _threadname;
};string toHex(pthread_t tid)
{char buffer[128];snprintf(buffer,sizeof(buffer),"0x%x",tid);return buffer;
}void* threadrun(void* argc)
{threadDate* td = static_cast<threadDate*>(argc);int i = 0;while(i < 10){printf("pid : %d,tid : %s,threadname : %s\n",getpid(),toHex(pthread_self()).c_str(),td->_threadname.c_str());sleep(1);i++;}delete td;
}int main()
{vector<pthread_t> tids;//创建多线程for(int i = 0; i < N; i++){pthread_t tid;threadDate* td = new threadDate(i);pthread_create(&tid,nullptr,threadrun,td);tids.push_back(tid);sleep(1);}for(int i = 0;i < tids.size();i++){pthread_join(tids[i],nullptr);}return 0;
}