【Linux】多线程1——线程概念与线程控制

这篇具有很好参考价值的文章主要介绍了【Linux】多线程1——线程概念与线程控制。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。


  • 📝 个人主页 :超人不会飞)
  • 📑 本文收录专栏:《Linux》
  • 💭 如果本文对您有帮助,不妨点赞、收藏、关注支持博主,我们一起进步,共同成长!

1. 线程概念

什么是线程

💭理解线程需要和进程的概念紧密联系。

  1. 线程是一个执行分支,执行粒度比进程更细,调度成本更低;
  2. 进程是分配系统资源的基本单位,线程是CPU调度的基本单位。
  3. 线程是运行在进程中的一个执行流,本质上是在进程的地址空间中运行,一个进程至少包含一个线程,称为主线程。

Linux中的线程

线程是操作系统中的抽象概念,用于实现多任务并发执行。不同的操作系统可以有不同的线程实现方法和模型。例如,在Windows操作系统中,与进程PCB对标的,构建了描述线程的数据结构 —— 线程控制块,但这样子设计有以下几个缺点:

  1. 创建线程在Windows中开销较大,因为它涉及到较多的内核资源和数据结构的分配
  2. 线程与进程无法统一组织起来
  3. 线程的调度效率低

Linux的设计者发现,线程控制块与进程控制块(PCB)大部分描述属性相同,且进程与其内部创建的线程看到的都是同一个地址空间。因此,在Linux中,线程控制块直接复用了PCB的代码,也就是说,Linux底层并没有真正的“线程”,这种复用之后的线程称之为轻量级进程

【Linux】多线程1——线程概念与线程控制,Linux,linux,运维,c++,操作系统

  • 每个轻量级进程(后面直接称为线程)都有自己的一个编号——LWP,同一个进程中的各个线程具有相同的PID。

🔎那我们之前讨论的进程是什么?这里都是轻量级进程的话,需要另有一个进程PCB来管理整个进程吗?

答案是不用。事实上,在Linux中,因为每个进程都至少有一个线程,即主线程(主执行流),这个线程的LWP和PID是相同的,因此,我们之前讨论的进程PCB,实际上就是这个主线程的task_struct。

ps -aL命令查看系统中的轻量级进程。

测试:在一个进程中,创建了10个线程,并用ps -aL命令查看。可以看到有一个主线程和10个新线程,主线程的PID和LWP相同。

【Linux】多线程1——线程概念与线程控制,Linux,linux,运维,c++,操作系统

  • 线程的调度成本低于进程,是因为同一个进程中的线程共享同一个地址空间,因此这些线程的调度只需要保存和更改一些上下文信息、CPU寄存器即可,如pc指针。而进程的调度需要修改较多的内存资源,如页表、地址空间等,而开销更大的是修改cache缓存的数据。

    cache缓存

    CPU内部的高速存储器中,保存着一些频繁访问的指令和数据,基于局部性原理,这些数据可能是未来将要被访问的,也可能是当前正在访问的。这么做的目的是减少CPU与内存的IO次数,以便快速响应CPU的请求,而不必每次都从较慢的内存中获取数据。不同进程的cache缓存数据是不同的,因此调度进程是需要切换这部分数据,而同一个进程的不同线程的cache缓存相同。

    CPU根据PID和LWP的对比,区分当前调度是线程级还是进程级,进而执行对应的调度策略。

线程的优点

  1. 线程占用的资源比进程少很多,因此创建线程的开销比创建进程小
  2. 线程的调度成本低于进程调度,线程切换时OS的工作量小
  3. 充分利用多处理器的可并行数量
  4. 在等待慢速I/O操作结束的同时,程序可执行其他的计算任务
  5. 计算密集型应用,为了能在多处理器系统上运行,将计算分解到多个线程中实现
  6. I/O密集型应用,为了提高性能,将I/O操作重叠。线程可以同时等待不同的I/O操作。

线程的缺点

  1. 性能损失。 一个很少被外部事件阻塞的计算密集型线程往往无法与其它线程共享同一个处理器。 如果计算密集型线程的数量比可用的处理器多,那么可能会有较大的性能损失,这里的性能损失指的是增加了额外的同步和调度开销,而可用的资源不变。 例如有10个处理器,11个线程,一对一的关系被破坏后,多出来的线程就增加了额外的调度开销。
  2. 复杂性和错误难以调试。 多线程编程涉及到共享资源、并发访问和同步等问题,这增加了程序的复杂性。
  3. 健壮性降低。 编写多线程需要更全面更深入的考虑,在一个多线程程序里,因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的,换句话说多线程之间是缺乏保护的。

⭕补充:

线程发生异常(如野指针、除零错误等),会导致线程崩溃,进而引发整个进程退出。从宏观角度,因为线程是进程的一个执行分支,线程干的事就是进程干的事,因此线程异常相当于进程异常,进程就会退出。从内核角度,线程出错,OS发送信号给进程,而不是单发给线程。

线程的独立资源和共享资源

进程是资源分配的基本单位,线程是调度的基本单位。一个进程中的多个线程共享线程数据,当然也有自己独立的数据。

线程的独立资源:

  • 寄存器中的上下文信息
  • 线程ID(在Linux中表现为LWP)
  • errno
  • 信号屏蔽字和未决信号集
  • 调度优先级

线程的共享资源:

  • 进程地址空间(包括进程的数据段、代码段等)
  • 文件描述符表
  • 每种信号的处理方式(SIG_ IGN、SIG_ DFL或者自定义的信号处理函数)
  • 当前工作目录
  • 用户ID和组ID

2. 线程控制

Linux的pthread库

Liunx中,提供给用户层进行线程控制的函数被打包在一个动态库中 —— pthread。使用线程控制接口时,需要包含头文件pthread.h,并在gcc/g++编译时加上-l pthread选项确定链接动态库。

/lib64目录下找到pthread库:

【Linux】多线程1——线程概念与线程控制,Linux,linux,运维,c++,操作系统

编译时应该添加的选项:

g++ threadTest.cc -o threadTest -l pthread # -lpthread也可以
  1. pthread_create

    功能:

    ​ 创建一个线程

    接口:

       int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
    

    参数:

    thread:线程库中定义了一个线程ID类型phtread_t,这里的thread是一个输出型参数,函数会向其指向的空间写入创建线程的ID

    attr:线程的属性,一般设为nullptr即可

    start_routine:线程执行的函数,是一个返回值类型void*,参数类型void*的函数指针

    arg:传入start_routine的参数,使用前后一般需要类型转换。

    返回值:

    RETURN VALUE
           On success, pthread_create() returns 0; on error, it returns an error number, and the contents of *thread are undefined.
    

💭关于线程退出的问题:

同子进程退出,需要父进程回收,线程也需要被另外的线程回收。回收的原因如下:1. 一个线程退出后,对应的资源不会被释放,而是留存在地址空间中。一个进程能运行的线程数是有限的,如果不加以回收,可能会导致内存泄漏!2. 一个线程退出后,其它线程可能需要获取其执行任务的结果。

  1. pthread_join

    功能:

    ​ 阻塞等待一个线程

    接口:

    int pthread_join(pthread_t thread, void **retval);
    

    参数:

    thread:线程ID

    retval:指向的空间中存储的是线程返回的结果(注意类型转换),因为线程函数的返回结果是void*类型,所以要用二级指针接收。如果不关心回收线程的结果,则设置为nullptr。

    返回值:

    RETURN VALUE
           On success, pthread_join() returns 0; on error, it returns an error number.
    
  2. pthread_exit

    线程函数中,可以直接用return退出线程并返回结果(可以被其它线程join接收)

    void *run(void *arg)
    {
        int cnt = 5;
        while (cnt--)
        {
            cout << "I am new thread" << endl;
            sleep(1);
        }
        return nullptr; //
    }
    

    也可以用pthread_exit函数。

    void pthread_exit(void *retval); //和return一样,返回一个void*指针
    

Linux中,线程只有joinable和unjoinable两种状态。默认情况下,线程是joinable状态,该状态下的线程退出后,占有资源不会被释放,必须等待其它线程调用pthread_join回收它,释放资源,或者进程退出,资源全部被释放。当然,可以通过调用pthread_detach分离线程,将线程设置为unjoinable状态,使其无需被等待回收,退出即被系统自动释放资源。

  1. pthread_detach

    功能:

    ​ 分离线程ID为thread的线程,使其无需被join等待。

    接口:

    int pthread_detach(pthread_t thread);
    

    返回值:

    RETURN VALUE
           On success, pthread_detach() returns 0; on error, it returns an error number.
    

线程分离可以由别的线程分离,也可以自己分离。

  1. pthread_self

    功能:

    ​ 获取当前线程的线程ID

    接口:

     pthread_t pthread_self(void);
    

测试

void *run(void *arg)
{
    int cnt = 10;
    while(cnt--)
    {
        cout << "I am new thread, cnt: " << cnt << endl;
        sleep(1);
    }
    pthread_exit(nullptr);
}

int main()
{
    cout << "I am main thread" << endl;

    pthread_t tid;
    pthread_create(&tid, nullptr, run, nullptr);

    int n = pthread_join(tid, nullptr);
    if (n != 0)
    {
        cout << "join new thread fail!!" << endl;
        exit(1);
    }
    cout << "join new thread success!!" << endl;
    return 0;
}

主线程创建新线程后,调用pthread_join会阻塞等待新线程退出。运行结果如下:

[ckf@VM-8-3-centos lesson9_thread]$ ./mythread 
I am main thread
I am new thread, cnt: 9
I am new thread, cnt: 8
I am new thread, cnt: 7
I am new thread, cnt: 6
I am new thread, cnt: 5
I am new thread, cnt: 4
I am new thread, cnt: 3
I am new thread, cnt: 2
I am new thread, cnt: 1
I am new thread, cnt: 0
join new thread success!!

可以在主线程中detach线程ID为tid的新线程,也可以在新线程中detach自己。

void *run(void *arg)
{
    //pthread_detach(pthread_self()); // 在新线程中detach自己
    int cnt = 10;
    while(cnt--)
    {
        cout << "I am new thread, cnt: " << cnt << endl;
        sleep(1);
    }
    pthread_exit(nullptr);
}

int main()
{
    cout << "I am main thread" << endl;

    pthread_t tid;
    pthread_create(&tid, nullptr, run, nullptr);

    pthread_detach(tid); // 在主线程中detach线程ID为tid的新线程
    int n = pthread_join(tid, nullptr);
    if (n != 0)
    {
        cout << "join new thread fail!!" << endl;
        exit(1);
    }
    cout << "join new thread success!!" << endl;
    return 0;
}
[ckf@VM-8-3-centos lesson9_thread]$ ./mythread 
I am main thread
join new thread fail!! #等待失败,pthread_join无法等待已分离的线程,返回值非0

如果在新线程中detach自己,可能依然能够join成功。要想成功detach线程,必须在join之前detach,因为调用pthread_join函数时,已经将线程视为joinable并阻塞等待了,此后再detach是无效的。上面代码中,如果在新线程中detach自己,由于主线程和新线程调度的先后顺序不确定性,很可能线程先join再detach,此时的detach是无效的。

  1. pthread_cancel

    功能:

    ​ 撤销(终止)一个线程ID为thread的线程

    接口:

    int pthread_cancel(pthread_t thread);
    

    返回值:

    RETURN VALUE
           On success, pthread_cancel() returns 0; on error, it returns a nonzero error number.
    

    撤销一个线程后,如果有另外的线程join该线程,那么其收到的退出结果是PTHREAD_CANCELED

    #define PTHREAD_CANCELED ((void *) -1)
    

测试

void *run(void *arg)
{
    while (true)
    {
        cout << "I am new thread" << endl;
        sleep(1);
    }
    pthread_exit(nullptr);
}

int main()
{
    cout << "I am main thread" << endl;

    pthread_t tid;
    pthread_create(&tid, nullptr, run, nullptr);

    sleep(3);
    pthread_cancel(tid);

    void *ret = nullptr;
    int n = pthread_join(tid, &ret);
    if (n != 0)
    {
        cout << "join new thread fail!!" << endl;
        exit(1);
    }
    if (ret == PTHREAD_CANCELED)
    {
        cout << "new thread is canceled" << endl;
    }
    cout << "join new thread success!!" << endl;

    return 0;
}
[ckf@VM-8-3-centos lesson9_thread]$ ./mythread 
I am main thread
I am new thread
I am new thread
I am new thread
new thread is canceled #新线程被撤销了
join new thread success!!

用户级线程

💭pthread库的线程控制接口,都不是直接操作Linux底层的轻量级进程,而是操作用户级线程。pthread库将底层的轻量级进程封装成为用户级线程,用户看到的便是线程而不是所谓的轻量级进程。动态库load到进程的共享区中,因此,用户级线程的空间也是load到进程的共享区中,线程的大部分独立资源保存在这块空间中,包括线程栈。

🔎线程库是怎么管理用户级线程的?

先描述再组织。 创建类似TCB的数据结构来描述线程,并将这些数据结构组织为一张表,如下。

【Linux】多线程1——线程概念与线程控制,Linux,linux,运维,c++,操作系统

  • 前面使用接口获取到的线程tid,其实就是该线程的用户级页表的首地址,只不过将其转换成整型的格式。

    int g_val = 100;
    
    string toHex(pthread_t tid)
    {
        char buf[64];
        snprintf(buf, sizeof(buf), "0x%x", tid);
        return string(buf);
    }
    
    void *run(void *arg)
    {
        cout << toHex(pthread_self()) << endl;
        pthread_exit(nullptr);
    }
    
    int main()
    {
        pthread_t t1;
        pthread_t t2;
    
        cout << "&g_val: " << &g_val <<endl;
        pthread_create(&t1, nullptr, run, nullptr);
        pthread_create(&t2, nullptr, run, nullptr);
    
        pthread_join(t1, nullptr);
        pthread_join(t2, nullptr);
    
        return 0;
    }
    
    [ckf@VM-8-3-centos lesson9_thread]$ ./mythread 
    &g_val: 0x6020cc #全局数据区
    0x4b30f700       #共享区
    0x4ab0e700		 #共享区
    
  • 全局变量默认是所有线程共享的,开发者需要处理多线程竞争问题。有些情况下我们需要保证一个线程独享一份数据,其它线程无法访问。这时候就要用到线程局部存储。gcc/g++编译环境中,可以__thread声明一个全局变量,从而每个线程都会独有一个该全局变量,存储在线程局部存储区中。

    __thread int g_val = 0; //__thread修饰全局变量,可以理解为从进程的全局变量变成线程的全局变量
    
    string toHex(pthread_t tid)
    {
        char buf[64];
        snprintf(buf, sizeof(buf), "0x%x", tid);
        return string(buf);
    }
    
    void *run(void *arg)
    {
        cout << "g_val: " << ++g_val << " " << "&g_val: " << &g_val << endl;
        pthread_exit(nullptr);
    }
    
    int main()
    {
        pthread_t t1;
        pthread_t t2;
        pthread_t t3;
    
        pthread_create(&t1, nullptr, run, nullptr);
        pthread_create(&t2, nullptr, run, nullptr);
        pthread_create(&t3, nullptr, run, nullptr);
        cout << "g_val: " << ++g_val << " " << "&g_val: " << &g_val << endl;
    
        pthread_join(t1, nullptr);
        pthread_join(t2, nullptr);
        pthread_join(t3, nullptr);
    
        return 0;
    }
    
    [ckf@VM-8-3-centos lesson9_thread]$ ./mythread #使用了线程局部存储
    g_val: 1 &g_val: 0x7fcb7cfcb77c
    g_val: 1 &g_val: 0x7fcb7bf366fc
    g_val: 1 &g_val: 0x7fcb7b7356fc
    g_val: 1 &g_val: 0x7fcb7af346fc
    
    [ckf@VM-8-3-centos lesson9_thread]$ ./mythread #未使用线程局部存储
    g_val: 1 &g_val: 0x6021d4
    g_val: 2 &g_val: 0x6021d4
    g_val: 3 &g_val: 0x6021d4
    g_val: 4 &g_val: 0x6021d4
    
  • 每个线程都有一个独立的栈结构,用于存储运行时的临时数据和压入函数栈帧。注意,主线程的栈就是进程地址空间中的栈。


ENDING…文章来源地址https://www.toymoban.com/news/detail-650133.html

到了这里,关于【Linux】多线程1——线程概念与线程控制的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Linux】多线程1——线程概念与线程控制

    📝 个人主页 :超人不会飞) 📑 本文收录专栏 :《Linux》 💭 如果本文对您有帮助,不妨 点赞、收藏、关注 支持博主,我们一起进步,共同成长! 💭理解线程需要和进程的概念紧密联系。 线程是一个执行分支,执行粒度比进程更细,调度成本更低; 进程是分配系统资源的

    2024年02月12日
    浏览(27)
  • 【Linux】操作系统与进程的概念

    目录 冯诺依曼体系 注意 为什么CPU不直接访问输入或输出设备? 跨主机间数据的传递 操作系统 管理 进程 描述进程 进程的查看和终止  bash 通过系统调用创建子进程 fork的辨析 🥖冯·诺依曼结构也称普林斯顿结构,是一种 将程序指令存储器和数据存储器合并在一起的存储器

    2024年01月18日
    浏览(45)
  • 【Linux】初步理解操作系统和进程概念

    操作系统是一款纯正的 “搞管理” 的文件 。 那操作系统为什么要管理文件? “管理” 又是什么? 它是怎么管理的? 1.操作系统帮助用户,管理好底层的软硬件资源; 2.为了给用户提供一个良好,安全的环境 即操作系统通过管理好底层的软硬件资源,为用户提供一个良好

    2024年02月15日
    浏览(39)
  • Linux:冯诺依曼系统和操作系统的概念

    本篇主要总结的是操作系统的基本认知和一些概念 那么上图表示的就是冯诺依曼体系结构,那这个体系结构是什么?为什么要先介绍它? 截止目前来说,常见的计算机都是遵循着冯诺依曼体系组成的,可以说有了冯诺依曼体系才能让计算机变得这么普及,才有了现在的互联

    2024年02月07日
    浏览(43)
  • 【Linux】进程概念I --操作系统概念与冯诺依曼体系结构

    Halo,这里是Ppeua。平时主要更新C语言,C++,数据结构算法…感兴趣就关注我吧!你定不会失望。 计算机是由两部分组成的: 硬件+软件 .与硬件相关的为 冯诺依曼体系结构 ,与软件相关的为: 操作系统 . 如今大多数计算机(笔记本,服务器等)大多数都遵守冯诺依曼体系结构.实际中

    2024年02月09日
    浏览(34)
  • 【Linux】冯诺伊曼体系结构|操作系统概念理解

    个人主页:🍝在肯德基吃麻辣烫 我的gitee:Linux仓库 个人专栏:Linux专栏 分享一句喜欢的话:热烈的火焰,冰封在最沉默的火山深处 本文进入Linux较为晦涩的概念——冯诺依曼体系结构和操作系统的理解。 冯诺依曼体系结构是我们日常计算机都遵守的一个整体架构,计算机

    2024年02月14日
    浏览(57)
  • 【Linux】冯诺依曼体系结构 && 操作系统 && 进程概念

    目录 一、冯诺依曼体系结构 二、操作系统  1、概念  2、设计OS的目的 三、进程  1、基本概念  2、描述进程-PCB  3、组织进程  4、查看进程和终止  5、通过系统调用获取进程标识符  6、通过系统调用创建进程-fork  7、进程状态  8、特殊进程    8.1 僵尸进程    8.2 孤儿进

    2024年02月10日
    浏览(57)
  • 【Linux】冯诺依曼体系结构和操作系统概念

    数学家冯·诺依曼提出了计算机制造的三个基本原则,即采用二进制逻辑、程序存储执行以及计算机由五个部分组成(运算器、控制器、存储器、输入设备、输出设备),这套理论被称为冯·诺依曼体系结构。 现代计算机发展所遵循的基本结构形式始终是冯·诺依曼机结构。这

    2024年02月02日
    浏览(53)
  • 【Linux】操作系统的基本概念 {冯诺依曼体系结构,操作系统的基本概念,系统调用及用户操作接口,shell程序}

    现代计算机设计大都遵守冯·诺依曼体系结构: 截至目前,我们所认识的计算机,都是由一个个的硬件组件组成 输入单元:包括键盘, 鼠标,扫描仪, 磁盘,网卡等 存储器: 内存(提高数据读写速度,降低硬件成本) 中央处理器(CPU):含有运算器(算数运算,逻辑运算)和控

    2024年02月11日
    浏览(48)
  • Linux复习 / 线程相关----线程概念与控制 Q&A梳理

    本篇博客梳理关于线程相关的QA,包括了线程概念与线程的控制。若读者也在复习这块知识,或者正在学习这块知识,可以通过这些QA检测自己的知识掌握情况。此外,思维导图已经更新至我的gitee,QA之外的体系梳理还请移步思维导图。 线程概念 Q:线程和进程的区别?(为

    2023年04月14日
    浏览(45)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包