【Linux】多线程操作

文章目录

  • 一. 线程库
  • 二. 多线程操作
    • 1. 线程创建
    • 2. 线程等待
    • 3. 线程退出
    • 4. 线程取消
    • 5. 线程分离
    • 6. 返回值
  • 三. 多线程理解
  • 结束语

一. 线程库

在Linux下,并没有真正的线程,只有用进程模拟的轻量级进程,所以Linux并没有提供可以直接创建线程的接口,但是通过进程模拟的轻量级进程,在用户感知和操作方面,和线程没有区别,所以Linux可以实现多线程
Linux提供了一个pthread — 线程库。如果需要实现多线程,那么在编译时就需要链接pthread这个动态库。使用时也需要包含pthread.h这个头文件
Linux默认都自带这个动态库

ldconfig -p | 库名 查看库的所处路径

在这里插入图片描述

二. 多线程操作

介绍完线程库,接下来我们就来学习几个线程操作

ps -aL 可以查看当前所有线程

1. 线程创建

线程创建的函数:pthread_create()

在这里插入图片描述
有四个参数,我们一一分析

参数 作用
pthread_t *thread 返回线程ID(输出型参数)
const pthread_attr_t *attr 设置线程属性(一般传nullptr,表示默认属性)
void*(start_routine)(void) 参数和返回值都是void*的函数指针,为线程的启动函数
void*arg 传给线程启动函数的参数

我们编写一个简单程序演示该函数的使用

#include
#include
#include

using namespace std;

#define NUM 10 // 创建线程的个数

//线程的启动函数
void* thread_run(void*args)
{
	//tname内容会传给args
	//因为args是void*类型,所有类型都可以接受
    char*tname=(char*)args;
    for(int i=0;i<2;i++)
    {
        cout<<"I am the "<<tname;
        sleep(1);
    }
    
   return nullptr;
}

int main()
{
    cout<<"I am the main stream"<<endl;
    sleep(1);
    pthread_t pth[NUM];

    for(int i=0;i<NUM;i++)
    {
    	//我们给启动函数传入线程编号
    	//格式:pthread[i]
        char tname[64];
        snprintf(tname,sizeof(tname),"pthread[%d]\n",i+1);
        
        pthread_create(pth+i,nullptr,thread_run,tname);
    }
    
    sleep(4);
    cout<<"多线程运行完毕"<<endl;

    return 0;
}

运行结果如下:
【Linux】多线程操作_第1张图片
PS:编译时需要链接pthread动态库

接下来,对上述程序做些解释

程序的目的是,创建10个线程,并通过传参,让每个线程打印内容,打印的内容是形式为 " I am the pthread[i] "

  1. 第一步,创建线程的第一个参数, pthread_t * thread 是一个输出型参数,我们要创建10个线程,所以要准备10个pthread_t ,所以我们提供一个pthread_t 数组,大小为10,pthread_t 本质是长整型
    在这里插入图片描述
  2. 线程是通过执行启动函数实现的,启动函数必须是返回值,参数都为void* 的一个函数,所以我们编写thread_run,同时pthread_create的最后一个参数void* arg是回调的参数,其会被传值给thread_run,所以args会接收arg。我们可以通过这个参数,传递我们想让线程完成的任务
  3. 我们想让线程打印的内容就可以通过arg传递过去,所以我们使用snprintf动态的传递一个字符串给thread_run启动函数,void * 可以接收任意类型,但是在使用时需要强转一下类型

但是运行结果怎么都是pthread[10]?
这是因为我们此时使用的是char* 临时变量,每次都被新的snprintf覆盖,而因为CPU运行过快,所以直接覆盖成最后的10,所以线程拿到的都是地址,访问都是同一块空间。
我们要想每次线程拿到的都是新的地址,可以使用new申请堆空间
【Linux】多线程操作_第2张图片

并且在启动函数中,我们使用完该堆区空间,还需要释放空间
【Linux】多线程操作_第3张图片

运行结果如下:

【Linux】多线程操作_第4张图片
我们还注意到一个现象,那就是并不是先创建的线程就先运行。实际上,线程的执行顺序由调度器决定,主线程和此线程在无其他干扰时也是如此,谁先调度由调度器决定。


我们再看一个现象

【Linux】多线程操作_第5张图片

我们让线程一直运行,而主线程创建10个线程后就结束,结果是如何呢?
【Linux】多线程操作_第6张图片

我们看到,线程都是运行了一次,然后程序就终止了
我们得出的结论是:主线程退出,相当于进程退出,进程退出,操作系统会回收分配给进程的资源,资源被回收,那么线程们也就无法运行,所以也终止了。

这一点与进程退出,子进程也退出成为孤儿进程,有些类型。


2. 线程等待

线程可以退出,那么自然主线程可以获取其退出信息

线程等待的函数是:pthread_join()
【Linux】多线程操作_第7张图片

参数 作用
pthread_t * thread 线程ID
void ** retval 返回线程的返回信息(输出型参数)

第一个参数是线程的ID
第二个参数其实就是启动函数的返回值,我们需要在主线程定义一个void*,来接收线程的返回值,因为需要修改void*的内容,所以参数是二级指针

我们举例以下程序,进行说明

#include
#include
#include

using namespace std;

#define NUM 5

//启动函数
//需要返回值和参数都是void*
void* thread_run(void*args)
{
    char*tname=(char*)args;
    for(int i=0;i<2;i++)
    {
        cout<<"I am the "<<tname;
        sleep(1);
    }
    
    delete tname;
    
    return (void*)10;
}

int main()
{
    cout<<"I am the main stream"<<endl;
    pthread_t pth[NUM];

    for(int i=0;i<NUM;i++)
    {
        // char tname[64];
        char *tname=new char[64];
        snprintf(tname,64,"pthread[%d]\n",i+1);
        pthread_create(pth+i,nullptr,thread_run,tname);
    }

    //接收返回的信息
    void*ret=nullptr;
    //线程等待
    for(int i=0;i<NUM;i++)
    {
        pthread_join(pth[i],&ret);
        cout<<"获取的退出信息:"<<(int_fast64_t)ret<<endl;
    }

    cout<<"多线程运行完毕"<<endl;
    
    return 0;
}

程序大致相同,我们这次只创建5个线程,但是在主线程中,我们使用pthread_join等待线程退出,同时创建void* ret接收线程退出的返回信息。
在线程的启动函数中,我们返回(void*)10

运行结果如下:
【Linux】多线程操作_第8张图片

所以我们传过去的ret,会成为输出型参数,接收线程退出的返回值。


3. 线程退出

线程退出和return 类似
退出的函数是:pthread_exit()

【Linux】多线程操作_第9张图片

参数 作用
void * retval 返回线程的返回信息

pthread_exit的使用类似return

【Linux】多线程操作_第10张图片

4. 线程取消

线程取消的函数是:pthread_cancel()
可以通过pthread_self()函数获取当前线程的ID

线程取消

【Linux】多线程操作_第11张图片

参数 作用
pthread_t thread 线程ID

获取线程ID

【Linux】多线程操作_第12张图片

pthread_cancel一般既可以由需终止的线程自己执行,也可以主线程调用,来终止该线程。不建议在子线程里终止主线程。

我们使用ps -aL可以查看当前运行的线程

【Linux】多线程操作_第13张图片

当线程后跟上< defunct >,表示该线程是僵尸线程,即其父线程没有回收该线程。

线程取消的方法是向目标线程发送CANCEL信号,但如何处理CANCEL信号则由目标线程自己决定,或者忽略,或立刻终止,或者继续运行值Cancelation-point(取消点),由不同的Cancekation状态决定。线程收到CANCEL信号的默认方式(即pthread_create()创建线程第二个参数为nullptr时),是继续运行至取消点,也就是说设置一个CANCELED状态,线程继续运行,只有运行至Cancelation-point的时候才会出现
pthread_join就是设置取消点的一种方式

PS: 如果一个子线程是被pthread_cancel取消的,那么该线程的返回值是PTHREAD_CANCELED,其实是(void*)-1

在这里插入图片描述

5. 线程分离

我们上面讲了主线程可以回收线程资源,需要线程等待。
其实创建一个线程,该线程中的属性默认是joinable的,也就是退出时,需要主线程回收资源,也就是pthread_join。否则无法释放资源,导致系统泄漏。
但是如果主线程不关心该线程的返回值,不想等待回收,那么我们可以分离该线程,也就是将该线程的属性从joinable改成detached
线程分离的函数是:pthread_detach()
【Linux】多线程操作_第14张图片

参数 作用
pthread_t thread 线程ID

可以是线程组的其他线程对目标线程进行分离,也可以是目标线程自己分离

PS:pthread_join和pthread_detach是冲突,一个线程如果已经分离,那么再对其进行等待会失败。

我们简单编写一段代码,展示该现象

#include
#include
#include
#include
#include
#include

using namespace std;


//启动函数
void* thread_run(void*args)
{
    while(true)
    {
        cout<<"线程运行中..."<<endl;
        sleep(1);
    }

    pthread_exit((void*)10);
}


 int main()
{
    cout<<"I am the main stream"<<endl;
    //线程ID
    pthread_t pth;
    //创建线程
    pthread_create(&pth,nullptr,thread_run,nullptr);
    //线程分离
    pthread_detach(pth);
    sleep(1);
    //线程等待
    int n=pthread_join(pth,nullptr);
    if(n!=0)
    {
        cerr<<"errno: "<<strerror(n)<<endl;
    }
    
    cout<<"主线程退出..."<<endl;
    return 0;
}

PS:此处我们先分离再等待。因为线程等待其实需要检查目标线程的属性,如果是joinable,则等待,如果是detached,则会失败。而失败则会返回错误码。

运行结果如下:

【Linux】多线程操作_第15张图片

我们看到分离后再等待,pthread_join返回错误码,错误为Invalid argument

6. 返回值

线程操作大部分返回值的描述都是这样的

在这里插入图片描述
我们以pthread_create作为举例

成功返回0,错误返回错误码
在大部分系统调用的返回值中,是成功返回0,错误设置错误码,也就是C语言的全局变量errno
但是因为多线程共享全局变量,所以每个线程错误都设置错误码的话,可以会互相影响,所以线程操作不设置错误码,而是返回错误码

三. 多线程理解

我们知道,动态库是在程序运行时,会加载到内存中,然后映射到虚拟地址空间的共享区。线程库为动态库,所以同样会映射到共享区中。
为了后续的理解,我们举个文件系统的例子作铺垫:
我们知道,打开文件在系统调用接口式open(),在C语言中是fopen,在C++中是fstream。
在操作系统层面,文件管理是文件描述符,在C语言中是struct FILE结构体,在C++中是类。

但是其实在语言层面只是对系统调用接口的封装,而线程库其实也是对系统调用接口的封装
pthread_create其实就是对clone的封装。
所以线程库同语言库,也需要对线程进行管理,所以在线程库中有管理线程的结构体

【Linux】多线程操作_第16张图片

mmap区域就是共享区

线程在内核中的编号是LWP,但我们通过pthread_self()返回的是线程ID,和LWP并不同。
线程库中的线程ID其实是一个虚拟地址,指向该管理该线程结构体的起始地址

线程栈
线程创建的临时变量会存储在线程栈中,也叫独立栈。
主线程的栈是虚拟地址的栈。

栈的存储其实使用了两个寄存器,一个是ebp寄存器,一个是esp寄存器
【Linux】多线程操作_第17张图片

ebp寄存器记录栈区的开始,不会改变
esp寄存器记录栈区的结束,会随着栈区数据增多而向下扩展
切换栈区,其实就是切换ebp和esp寄存器。

线程局部存储

当多个线程使用主线程创建的全局变量时,如果要互补影响,可以将该全局变量拷贝一份到线程局部存储中。
gcc/g++实现的方式是在全局变量前加__thread。如:

__thread int g_val=100;

结束语

本篇内容到此就结束了,感谢你的阅读!

如果有补充或者纠正的地方,欢迎评论区补充,纠错。如果觉得本篇文章对你有所帮助的话,不妨点个赞支持一下博主,拜托啦,这对我真的很重要。
在这里插入图片描述

你可能感兴趣的:(Linux学习笔记,linux,运维,服务器)