Linux 多线程(线程控制(创建/终止/等待/分离))

曾经终败给现在 2023-07-10 12:45 37阅读 0赞

**目录**

POSIX线程库

创建线程

线程ID及进程地址空间布局

线程终止

线程等待

线程分离

--------------------

**线程概念/特点/优缺点/与进程比较** 写在另一篇博客

[戳链接（￣︶￣）↗https://blog.csdn.net/qq\_41071068/article/details/104571277][https_blog.csdn.net_qq_41071068_article_details_104571277]

## POSIX线程库 ##

> **POSIX线程**(POSIX Threads, 常缩写为Pthreads)是[POSIX][]的[线程][Link 1]标准, 定义了创建和操纵线程的一套[API][](应用程序编程接口).
> 
> 由于Linux内核不区分线程和进程, 所以操作系统并没有向用户提供创建线程的接口, 为此大佬们封装了一套线程控制接口
> 
>  *  POSIX线程库中绝大多数函数的名字都是以“pthread\_”打头的
>  *  要使用这些函数库，要加头文<pthread.h>
>  *  在最后编译链接时, 要添加 -pthread或-lpthread选项, 用来链接POSIX线程库(注 : gcc4.5.2往后就已经没有-lpthread的介绍了, 所以往后选用-pthread)

## 创建线程 ##

> 与创建进程的函数fork()类似, 其实fork()和pthread\_create()内部都调用了clone(). 
> 
> **原型 : int pthread\_create(pthread\_t\* tid, const pthread\_attr\_t\* attr, void\* (\*start\_routine)(void\* arg), void\* arg) ;**
> 
> **功能 :** 创建一个新线程
> 
> **参数 :  tid :** 输出型参数, 获取线程id(这个线程id下面细说)  
> **           attr :** 设置线程的属性，传入NULL表示使用默认属性  
>            **start\_routine : **是一个函数指针, 传入线程入口函数 , 其中arg是线程入口函数的形参( 创建一个线程就是为了运行传                                      入的函数指针所指向的函数, 函数运行完毕, 则线程退出)  
>            **arg :** 是传入的线程入口函数的参数
> 
> **返回值 :** 返回值为0, 表示创建成功, 返回值 > 0, 则表示失败, 返回的是errno

来看个例子 .

#include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<unistd.h>
    #include<pthread.h>
    void* thread_start(void* arg){
        while(1){
            printf("主线程向我传递了一个参数:%s\n", (char*)arg);
            sleep(1);
        }
        return NULL;
    }
    int main(){
        pthread_t tid;
        char buf[] = "哈哈哈哈";
        int ret = pthread_create(&tid, NULL, thread_start, (void*)buf);
        if(ret){
            fprintf(stderr, "pthread_create: %s\n", strerror(ret));//strerror函数
            //perror("pthread_create:");//如果置全局的errno, 则可以直接用perror, 
            //但pthread_create并不会改变全局的errno, 而是将errno返回
            return -1;
        }
        while(1){
            printf("我是主线程\n");
            sleep(1);
        }
        return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70][]

![20200302210139709.png][]

--------------------

## 线程ID及进程地址空间布局 ##

**线程id和进程id**

> 在没有学习线程之前, 我们将PCB中的pid作为一个进程的id来标识一个进程, 但当引入线程的概念后, 就不能再这样理解. 当
> 
> 一个进程有多个线程时, 每个线程在内核中都有一个PCB, 每个PCB都有唯一的pid, 那么此时的进程id又是什么呢, 其实这
> 
> 时候我们所说的进程id是就是PCB中tgid (thread group id), 同组线程PCB中的tgid都是相同的, 对应的就是我们能看见的进程
> 
> id, 而线程id就是其各自PCB唯一的pid(之前我们认为的进程id变为了现在的线程id), 就拿上面的图为例.

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 1][]

再来看pthread\_create() 函数中所获取的线程id

*  pthread\_ create函数会产生一个线程id, 存放在第一个参数指向的地址中. 这里的线程id和上面所说的线程id不是一回事.  
     
 *  上面所说的线程id属于内核调度的范畴, 因为线程是轻量级进程, 是操作系统调度的最小单位, 所以需要一个唯一标识 .  
     
 *  而这里pthread\_create()函数第一个参数返回的值是**指向一个虚拟内存单元的指针**, 也就是说这个内存单元的首地址即为新创建线程的线程id  
     
 *  那么这个线程id(指针)指向的内存单元到底是什么呢?由于线程库函数并不是内核提供的, 所以线程库函数无法直接对内核中  
    线程的PCB操作, 所以在创建线程时, 在虚拟内存空间上也分配了一块空间来存储线程描述信息, 线程库函数通过在找到线程描述信息进而访问在内核中的线程的PCB, 现在就比较清楚了, **这里的线程id纯粹就是为了线程库函数要完成对线程的控制而存在的. 当脱离线程库函数后就失去意义. **
 *   
 *  ![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 2][]  
    (mmap是一种内存映射文件的方法，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一 一对映关系)  
     
 *  线程库中其他函数的后续操作, 就是根据该线程ID来操作线程的.  
     
 *  这样pthread\_t 的类型也就知道了, pthread\_t是一个指针类型.

**pthread\_ self函数，可以获得线程自身的ID**

> **原型 : pthread\_t pthread\_self( )**
> 
> **功能 :** 获取线程自身id
> 
> **返回值 :** 线程自身id

#include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<unistd.h>
    #include<pthread.h>
    void* thread_start(void* arg){
        sleep(1);
        printf("ID:%p,主线程向我传递了一个参数:%s\n", pthread_self(), (char*)arg);
        return NULL;
    }
    int main(){
        pthread_t tid;
        char buf[] = "哈哈哈哈";
        int ret = pthread_create(&tid, NULL, thread_start, (void*)buf);
        if(ret){
            fprintf(stderr, "pthread_create: %s\n", strerror(ret));//strerror函数
            //perror("pthread_create:");//如果置全局的errno, 则可以直接用perror, 
            //但pthread_create并不会改变全局的errno, 而是将errno返回
            return -1;
        }
        printf("我是主线程, ID:%p, 创建的线程ID:%p\n", pthread_self(), tid);
        sleep(1);
        return 0;
    }

![20200302235951693.png][]

--------------------

##  线程终止 ##

> 如果需要只终止某个线程而不终止整个进程,可以有三种方法:
> 
>  *  线程函数中 return. 这种方法对主线程不适用, 从main函数中return相当于调用exit(), 是退出进程
>  *  线程调用库函数pthread\_ exit()终止自己.
>  *  一个线程可以调用pthread\_ cancel()可以终止同一进程中(线程组中)的另一个线程.
> 
> 具体来看

> **原型 : void pthread\_exit(void\* retval)**
> 
> **功能 :** 谁调用, 谁退出
> 
> **参数 :** **retval :** 输出型参数, 返回线程的退出状态, 不关心可以置NULL. 
> 
> **返回值 :** 无
> 
> 注意 : 不能将retval指向线程函数内的局部变量(临时变量), 一般是指向全局变量或是堆区的变量, return也是同样的道理.

> **原型 : int pthread\_cancel(pthread\_t tid)**
> 
> **功能 :** 退出同组线程中, 线程id是tid的线程
> 
> **参数 :** **tid** : 线程id
> 
> **返回值 :** 为0, 则成功, 返回值>0, 返回的是错误码errno

**注意 :** 在线程入口函数中可以使用exit() 或 \_exit()吗 ? 在线程中使用它们两都说使整个进程退出(线程组都退出). 所以一般不用.

--------------------

## 线程等待 ##

> 不难发现, 当return 或者pthread\_exie()时, 返回的结果去哪儿了 ? 其实, 当线程退出后, 其空间并没有释放, 任然在进程的地
> 
> 址空间内, 创建新的线程不会再复用刚才退出线程的地址空间(因为没有释放啊), 所以为了获取线程返回状态, 我们需要线程
> 
> 等待.

> **原型 : int pthread\_join(pthread\_t tid, void\*\* retval) **
> 
> **功能 : **等待指定线程退出, 获取其退出状态
> 
> **参数 : tid :** 需要等待退出的线程id  
>           **retval :** 输出型参数, 二级指针, 指向线程退出时返回的指针, 线程退出时返回的指针指向线程退出状态(返回值).
> 
> **返回值 :** 成功返回0, 失败返回值>0, 返回的是错误码errno
> 
> 注意 : 调用这个函数的线程将挂起等待(谁调用的谁挂起等待), 直到id为tid的线程终止. 线程id是tid的线程以不同的方法终止,
> 
> 通过pthread\_join得到的终止状态是不同的，分别如下:
> 
>  *  return 退出, retval指向的是 return 返回的值
>  *  pthread\_exit() 退出时, retval指向的是pthread\_exit()的参数
>  *  被pthread\_cancel异常终止, retval的值是宏 PTHREAD\_ CANCELED
>  *  当不关心线程的推出状态时, retval的可以置NULL

举个栗子 :

#include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<unistd.h>
    #include<pthread.h>
    using namespace std;
    int n = 2;
    void* thread_start1(void* arg){
        int* p = new int;
        *p = 1;
        return (void*)p;
    }
    void* thread_start2(void* arg){
        int *p = &n;
        pthread_exit((void*)p);
    }
    void* thread_start3(void* arg){
        while(1){
            sleep(1);
            printf("thread3 is runing ...\n");
        }
        return NULL;
    }
    
    int main(){
        pthread_t tid[3];
        void* (*thread_start[3])(void*) = {thread_start1, thread_start2, thread_start3};
        int ret;
        for(int i = 0; i < 3; ++i){
            ret = pthread_create(&tid[i], NULL, thread_start[i], NULL);
            if(ret){
                fprintf(stderr, "pthread_create%d: %s\n", i + 1, strerror(ret));
                return -1;
            }
        }
        int* retval;
        pthread_join(tid[0], (void**)&retval);
        printf("thread%d返回值为%d\n", 1, *retval);
        delete retval;
        pthread_join(tid[1], (void**)&retval);
        printf("thread%d返回值为%d\n", 2, *retval);
        sleep(3);
        pthread_cancel(tid[2]);
        pthread_join(tid[2], (void**)&retval);
        if(retval == PTHREAD_CANCELED){
            printf("thread3 return code:PTHREAD_CANCELED\n");
        }
        else{
            printf("thread%d返回值为%d\n", 2, *retval);
        }
        return 0;
    }

![20200303162707655.png][]

--------------------

##  线程分离 ##

> 默认情况下，pthread\_create() 新创建的线程是joinable的, 线程退出后, 需要对其进行pthread\_join操作, 否则无法释放资源, 会造成内存泄漏 .
> 
> 但当我们不关心线程的返回值, joinable属性就成为了一种负担, 这个时候, 我们可以告诉系统, 当线程退出时, 自动释放线程资源. 我们就不需要再管了.

> **原型 : int pthread\_detach(pthread\_t tid)**
> 
> **功能 :** 分离指定的线程(将指定的线程属性设置为detach)
> 
> **参数 : tid :** 需要分离的线程id
> 
> **返回值 :** 成功返回0, 失败返回值>0, 返回的是错误码errno
> 
> **注意 :**
> 
>  *  pthread\_detach() 可以是线程组内其他线程对目标线程进行分离 : pthread\_detach(tid) //tid为要分离的同组线程id
>  *  也可以是线程自己分离 : pthread\_detach(pthread\_self()) 
>  *  线程分离只是给线程更改一下属性, 所以可以在线程入口函数中让线程自己分离自己,  也可以在主线程中创建线程之后直接分离
>  *  一个线程的属性不能使即joinable又detach. 当线程被分离后就不能再pthread\_join()了. 等待一个已经被分离的线程, pyhread\_join会返回错误

举个栗子 :

#include<iostream>
    #include <cstdio>
    #include <cstring>
    #include <unistd.h>
    #include <pthread.h>
    using namespace std;
    void* thread_start1(void* arg) {
        pthread_t tid = pthread_self();
        int ret = pthread_detach(tid);
        if(ret){
            fprintf(stderr, "pthread_detach thread1:%s\n", strerror(ret));
        }
        else{
            printf("thread1, id:%p已分离\n", tid);
        }
        usleep(1000);
        return NULL;
    }
    void* thread_start2(void* arg){
        usleep(1000);
        return NULL;
    }
    void* thread_start3(void* arg){
        pthread_t tid = pthread_self();
        int ret = pthread_detach(tid);
        if(ret){
            fprintf(stderr, "pthread_detach thread3:%s\n", strerror(ret));
        }
        else{
            printf("thread3, id:%p已分离\n", tid);
        }
        usleep(1000);
        return NULL;
    }
    int main() {
        pthread_t tid;
        //thread1
        int ret = pthread_create(&tid, NULL, thread_start1, NULL);
        if (ret){
            fprintf(stderr, "pthread_create thread1:%s\n", strerror(ret));
            return -1;
        }
        //thread2
        usleep(100);
        ret = pthread_create(&tid, NULL, thread_start2, NULL);
        if (ret){
            fprintf(stderr, "pthread_create thread2:%s\n", strerror(ret));
            return -1;
        }
        ret = pthread_detach(tid);
        if(ret){
            fprintf(stderr, "pthread_detach thread2:%s\n", strerror(ret));
        }
        else{
            printf("thread2, id:%p已分离\n", tid);
        }
        //thread3
        ret = pthread_create(&tid, NULL, thread_start3, nullptr);
        if (ret){
            fprintf(stderr, "pthread_create thread3:%s\n", strerror(ret));
            return -1;
        }
        usleep(1000);//必须要睡一下,要让线程先分离，再等待
        //线程被创建, 但创建的线程中的分离语句和下面的join语句
        //哪个先执行还真不一定, 所以说要先睡一下
        ret = pthread_join(tid, NULL);
        if (ret == 0) {
            printf("pthread3 wait success\n");
    
        } else {
            fprintf(stderr, "pthread3 wait failed:%s\n", strerror(ret));
        }
        return 0;
    }

![2020030319021176.png][]

[https_blog.csdn.net_qq_41071068_article_details_104571277]: https://blog.csdn.net/qq_41071068/article/details/104571277
[POSIX]: https://baike.baidu.com/item/POSIX
[Link 1]: https://baike.baidu.com/item/%E7%BA%BF%E7%A8%8B
[API]: https://baike.baidu.com/item/API
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020030300033517.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4,size_16,color_FFFFFF,t_70
[20200302210139709.png]: https://img-blog.csdnimg.cn/20200302210139709.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020030222384459.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200302234020660.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4,size_16,color_FFFFFF,t_70
[20200302235951693.png]: https://img-blog.csdnimg.cn/20200302235951693.png
[20200303162707655.png]: https://img-blog.csdnimg.cn/20200303162707655.png
[2020030319021176.png]: https://img-blog.csdnimg.cn/2020030319021176.png