-
【Linux练习生】Linux多线程
本节重点
- 了解线程概念，理解线程与进程区别与联系。
- 了解线程控制，线程创建，线程终止，线程等待，线程分离。
- 了解线程ID。
Linux线程概念
线程的概念理解
线程（英文：thread），操作系统技术中的术语，是操作系统能够进行运算调度的最小单位，它被包涵在进程之中，是行程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并行多个线程，每条线程并行执行不同的任务。在Unix SystemV及SunOS中也被称为轻量进程（lightweight processes），但轻量进程更多指内核线程(kernel thread)，而把用户线程(user thread)称为线程。计算机科学术语，指运行中的程序的调度单位。
- 在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”。
- 一切进程至少都有一个执行线程。
- 线程在进程内部运行，本质是在进程地址空间内运行。
- 在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更轻量化。
- 透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流。
以整个运行视角理解：
程序运行，将代码和数据加载到CPU上，同时系统创建对应的进程进行承担分配系统资源，如创建task_struct结构体，构建对应的进程地址空间，页表建立虚拟地址与物理地址的映射等等，即进程是承担分配系统资源的基本单元
在进程中可能存在多个执行流（一定有个主执行流），也就是线程，而这些执行流都是由task_struct描述的，共享同一个进行地址空间，透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流，执行程序的部分代码，这些执行流可以进行并发执行，由于是在进行内部运行，不用切换整个进程的上下文数据，只需切换线程的上下文数据，即线程是系统调度的基本单元。
在Linux系统下的CPU眼中，看到的PCB(task_struct)都要比传统的进程更加轻量化在Linux中，站在CPU的角度，能否识别当前调度的task_struct是进程还是线程？
答案是不能，也不需要了，因为CPU只关心一个一个的独立执行流。无论进程内部只有一个执行流还是有多个执行流，CPU都是以task_struct为单位进行调度的。
因此，CPU看到的虽说还是task_struct，但已经比传统的进程要更轻量化了。
Linux下并不存在真正的多线程！而是用进程模拟的！
操作系统中存在大量的进程，一个进程内又存在一个或多个线程，因此线程的数量一定比进程的数量多，当线程的数量足够多的时候，很明显线程的执行粒度要比进程更细。
如果一款操作系统要支持真的线程，那么就需要对这些线程进行管理。比如说创建线程、终止线程、调度线程、切换线程、给线程分配资源、释放资源以及回收资源等等，所有的这一套相比较进程都需要另起炉灶，搭建一套与进程平行的线程管理模块。
因此，如果要支持真的线程一定会提高设计操作系统的复杂程度。在Linux看来，描述线程的控制块和描述进程的控制块是类似的，因此Linux并没有重新为线程设计数据结构，而是直接复用了进程控制块，所以我们说Linux中的所有执行流都叫做轻量级进程。
但也有支持真的线程的操作系统，比如Windows操作系统，因此Windows操作系统系统的实现逻辑一定比Linux操作系统的实现逻辑要复杂得多。
既然在Linux没有真正意义的线程，那么也就绝对没有真正意义上的线程相关的系统调用！
既然在Linux中都没有真正意义上的线程了，那么自然也没有真正意义上的线程相关的系统调用了。但是Linux提供了轻量级进程相关的库和接口，例如vfork函数和原生线程库pthread。
vfork函数/pthread线程库
vfork函数的功能就是创建子进程，但是父子共享空间，v函数fork的函数原型如下：
pid_t vfork(void);- 1
vfork函数的返回值与fork函数的返回值相同：
- 给父进程返回子进程的PID。
- 给子进程返回0。
在下面的代码中，父进程使用vfork函数创建子进程，子进程将全局变量g_val由100改为了200，父进程休眠3秒后再读取到全局变量g_val的值。
#include#include #include #include int g_val = 100; int main() { pid_t id = vfork(); if (id == 0){ //child g_val = 200; printf("child:PID:%d, PPID:%d, g_val:%d\n", getpid(), getppid(), g_val); exit(0); } //father sleep(3); printf("father:PID:%d, PPID:%d, g_val:%d\n", getpid(), getppid(), g_val); return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
运行程序的话我们可以看到，父进程读取到g_val的值是子进程修改后的值，也就证明了vfork创建的子进程与其父进程是共享地址空间的。
注意：vfork() 保证子进程先运行，在它调用 exec（进程替换） 或 exit（退出进程）之后父进程才可能被调度运行；如果子进程没有调用 exec, exit, 程序则会导致死锁，程序是有问题的程序，没有意义。
原生线程库pthread
在Linux中，站在内核角度没有真正意义上线程相关的接口，但是站在用户角度，当用户想创建一个线程时更期望使用thread_create这样类似的接口，而不是vfork函数，因此系统为用户层提供了原生线程库pthread。
原生线程库实际就是对轻量级进程的系统调用进行了封装，在用户层模拟实现了一套线程相关的接口。
因此对于我们来讲，在Linux下学习线程实际上就是学习在用户层模拟实现的这一套接口，而并非操作系统的接口。
线程属性
在多线程OS中，通常是在一个进程中包括多个线程，每个线程都是作为利用CPU的基本单位，是花费最小开销的实体。线程具有以下属性。
1）轻型实体
线程中的实体基本上不拥有系统资源，只是有一点必不可少的、能保证独立运行的资源，比如，在每个线程中都应具有一个用于控制线程运行的线程控制块TCB，用于指示被执行指令序列的程序计数器、保留局部变量、少数状态参数和返回地址等的一组寄存器和堆栈。
2）独立调度和分派的基本单位。
在多线程OS中，线程是能独立运行的基本单位，因而也是独立调度和分派的基本单位。由于线程很“轻”，故线程的切换非常迅速且开销小。
3）可并发执行。
在一个进程中的多个线程之间，可以并发执行，甚至允许在一个进程中所有线程都能并发执行；同样，不同进程中的线程也能并发执行。
4）共享进程资源。
在同一进程中的各个线程，都可以共享该进程所拥有的资源，这首先表现在：所有线程都具有相同的地址空间（进程的地址空间），这意味着，线程可以访问该地址空间的每一个虚地址；此外，还可以访问进程所拥有的已打开文件、定时器、信号量机构等。
线程的优点
- 创建一个新线程的代价要比创建一个新进程小得多。
- 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多。
- 线程占用的资源要比进程少很多。
- 能充分利用多处理器的可并行数量。
- 在等待慢速IO操作结束的同时，程序可执行其他的计算任务。
- 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现。
- IO密集型应用，为了提高性能，将IO操作重叠，线程可以同时等待不同的IO操作。
计算密集型：执行流的大部分任务，主要以计算为主。比如加密解密、大数据查找等(主要使用的CPU资源)。
IO密集型：执行流的大部分任务，主要以IO为主。比如刷磁盘、访问数据库、访问网络等（内存和外设的IO资源）。线程的缺点
- 性能损失： 一个很少被外部事件阻塞的计算密集型线程往往无法与其他线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。
- 健壮性降低： 编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说，线程之间是缺乏保护的。
- 缺乏访问控制： 进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。
- 编程难度提高： 编写与调试一个多线程程序比单线程程序困难得多。
线程异常
- 单个线程如果出现除零、野指针等问题导致线程崩溃，进程也会随着崩溃。
- 线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该进程内的所有线程也就随即退出。
线程用途
- 合理的使用多线程，能提高CPU密集型程序的执行效率。
- 合理的使用多线程，能提高IO密集型程序的用户体验（如生活中我们一边写代码一边下载开发工具，就是多线程运行的一种表现）。
Linux进程VS线程
进程与线程的区别
线程和进程的区别在于，子进程和父进程有不同的代码和数据空间，而多个线程则共享数据空间，每个线程有自己的执行堆栈和程序计数器为其执行上下文。多线程主要是为了节约CPU时间，发挥利用，根据具体情况而定。线程的运行中需要使用计算机的内存资源和CPU。
通常在一个进程中可以包含若干个线程，它们可以利用进程所拥有的资源。在引入线程的操作系统中，通常都是把进程作为分配资源的基本单位，而把线程作为独立运行和独立调度的基本单位。由于线程比进程更小，基本上不拥有系统资源，故对它的调度所付出的开销就会小得多，能更高效的提高系统内多个程序间并发执行的程度，从而显著提高系统资源的利用率和吞吐量。
线程共享进程数据，但也拥有自己的一部分数据：
- 线程ID。
- 一组寄存器。（存储每个线程的上下文信息）
- 栈。（每个线程都有临时的数据，需要压栈出栈）
- errno。（C语言提供的全局变量，每个线程都有自己的）
- 信号屏蔽字。
- 调度优先级。
进程的多个线程共享
因为是在同一个地址空间，因此所谓的代码段（Text Segment）、数据段（Data Segment）都是共享的：
- 如果定义一个函数，在各线程中都可以调用。
- 如果定义一个全局变量，在各线程中都可以访问到。
除此之外，各线程还共享以下进程资源和环境：
- 文件描述符表。（进程打开一个文件后，其他线程也能够看到）
- 每种信号的处理方式。（SIG_IGN、SIG_DFL或者自定义的信号处理函数）
- 当前工作目录。（cwd）
- 用户ID和组ID。
进程和线程的关系包括为：
单线程进程 ; 单进程多线程; 多个单线程进程;多个多线程进程
Linux线程控制
POSIX线程库
pthread线程库是应用层的原生线程库：
- 应用层指的是这个线程库并不是系统接口直接提供的，而是由第三方帮我们提供的。
- 原生指的是大部分Linux系统都会默认带上该线程库。
- 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的。
- 要使用这些函数库，要通过引入头文件
。 - 链接这些线程函数库时，要使用编译器命令的“-lpthread”选项。
错误检查：
- 传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误。
- pthreads函数出错时不会设置全局变量errno（而大部分POSIX函数会这样做），而是将错误代码通过返回值返回。
- pthreads同样也提供了线程内的errno变量，以支持其他使用errno的代码。对于pthreads函数的错误，建议通过返回值来判定，因为读取返回值要比读取线程内的errno变量的开销更小。
线程创建
创建线程的函数叫做pthread_create
pthread_create函数的函数原型如下：
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);- 1
参数说明：
- thread：获取创建成功的线程ID，该参数是一个输出型参数。
- attr：用于设置创建线程的属性，传入NULL表示使用默认属性。
- start_routine：该参数是一个函数地址，表示线程例程，即线程启动后要执行的函数。
- arg：传给线程例程的参数。
返回值说明：
线程创建成功返回0，失败返回错误码。
让主线程创建一个新线程
当一个程序启动时，就有一个进程被操作系统创建，与此同时一个线程也立刻运行，这个线程就叫做主线程。
- 主线程是产生其他子线程的线程。
- 通常主线程必须最后完成某些执行操作，比如各种关闭动作。
下面我们让主线程调用pthread_create函数创建一个新线程，此后新线程就会跑去执行自己的新例程，而主线程则继续执行后续代码。
我们编写一个简单的程序：
1 #include<stdio.h> 2 #include<pthread.h> 3 #include<unistd.h> 4 5 void *thread_run(void *args) 6 { 7 const char *id=(const char*)args; 8 while(1) 9 { 10 printf("我是%s线程， %d\n",id,getpid()); 11 sleep(1); 12 } 13 } 14 15 16 17 int main() 18 { 19 pthread_t tid; 20 pthread_create(&tid,NULL,thread_run,(void*)"thread 1");//创建线程 21 22 while(1) 23 { 24 printf("我是main线程，%d\n",getpid()); 25 sleep(1); 26 } 27 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
我们通过线程库的pthread_create创建一个thread 1线程，并执行thread_run函数，然后分别在main线程和thread 1线程执行一个死循环。
接着我们通过gcc形成可执行文件后执行程序，可以看到两个死循环都执行了，这说明此时有两个执行流在运行，因为一个执行流是不可能同时执行两个死循环的，但是这两个执行流的pid是一样的，也就是说此时依旧只有一个进程，只不过进程内部有两个线程属于这个进程。
因此，我们杀掉进程pid为2924的进程后，这两个死循环（执行流）都退出了。使用ps -aL命令，可以显示当前的轻量级进程。
- 默认情况下，不带-L，看到的就是一个个的进程。
- 带-L就可以查看到每个进程内的多个轻量级进程。
其中，LWP（Light Weight Process）就是轻量级进程的ID，可以看到显示的两个轻量级进程的PID是相同的，因为它们属于同一个进程。注意：
在Linux中，应用层的线程与内核的LWP是一一对应的，实际上操作系统调度的时候采用的是LWP，而并非PID，只不过我们之前接触到的都是单线程进程，其PID和LWP是相等的，所以对于单线程进程来说，调度时采用PID和LWP是一样的。获取线程ID
常见获取线程ID的方式有两种：
- 创建线程时通过输出型参数获得。
- 通过调用pthread_self函数获得。
pthread_self函数的函数原型如下：
pthread_t pthread_self(void);- 1
调用pthread_self函数即可获得当前线程的ID，类似于调用getpid函数获取当前进程的ID。
例如，下面代码中在新线程被创建后，主线程通过输出型参数获取到线程ID进行打印，此后新线程又通过调用thread_run函数将获取到自身的线程ID通过pthread_self函数进行打印。
1 #include<stdio.h> 2 #include<pthread.h> 3 #include<unistd.h> 4 5 void *thread_run(void *args) 6 { 7 8 while(1) 9 { 10 printf("我是新线程[%s]，我创建的线程ID是： %lu\n",(const char*)args,pthread_self()); 11 sleep(1); 12 } 13 } 14 15 16 17 int main() 18 { 19 pthread_t tid; 20 pthread_create(&tid,NULL,thread_run,(void*)"thread 1"); 21 22 while(1) 23 { 24 printf("我是main线程，我创建的线程ID是：%lu\n",tid); 25 sleep(1); 26 } 27 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
运行代码，可以看到这两种方式获取到的线程的ID是一样的。
注意：
用pthread_self函数获得的线程ID与内核的LWP的值是不相等的，pthread_self函数获得的是用户级原生线程库的线程ID，而LWP是内核的轻量级进程ID，它们之间是一对一的关系。线程等待
一个线程被创建出来，这个线程就如同进程一般，也是需要被等待的。如果主线程不对新线程进行等待，那么这个新线程的资源也是不会被回收的。所以线程需要被等待，如果不等待会产生类似于“僵尸进程”的问题，也就是内存泄漏。
等待线程的函数叫做pthread_join
pthread_join函数的函数原型如下：
int pthread_join(pthread_t thread, void **retval);- 1
参数说明：
- thread：被等待线程的ID。
- retval：线程退出时的退出码信息。
返回值说明：
- 线程等待成功返回0，失败返回错误码。
- 调用该函数的线程将挂起等待，直到ID为thread的线程终止，thread线程以不同的方法终止，通过pthread_join得到的终止状态是不同的。
总结如下：
- 如果thread线程通过return返回，retval所指向的单元里存放的是thread线程函数的返回值。
- 如果thread线程被别的线程调用pthread_cancel异常终止掉，retval所指向的单元里存放的是常数PTHREAD_CANCELED。
- 如果thread线程是自己调用pthread_exit终止的，retval所指向的单元存放的是传给pthread_exit的参数。
- 如果对thread线程的终止状态不感兴趣，可以传NULL给retval参数。
用grep命令进行查找，可以发现PTHREAD_CANCELED实际上就是头文件
里面的一个宏定义，它的值本质就是-1。 cpp $ grep -ER "PTHREAD_CANCELED" /usr/include/例如，在下面的代码中我们先不关心线程的退出信息，直接将pthread_join函数的第二个参数设置为NULL，等待线程后打印该线程的编号以及线程ID。
#include#include #include #include #include void* Routine(void* arg) { char* msg = (char*)arg; int count = 0; printf("I am %s...pid: %d, ppid: %d, tid: %lu\n", msg, getpid(), getppid(), pthread_self()); sleep(1); return NULL; } int main() { pthread_t tid[5]; for (int i = 0; i < 5; i++){ char* buffer = (char*)malloc(64); sprintf(buffer, "thread %d", i); pthread_create(&tid[i], NULL, Routine, buffer); //printf("%s tid is %lu\n", buffer, tid[i]); } printf("I am main thread...pid: %d, ppid: %d, tid: %lu\n", getpid(), getppid(), pthread_self()); for (int i = 0; i < 5; i++){ pthread_join(tid[i], NULL); printf("thread %d[%lu]...quit\n", i, tid[i]); } return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
运行代码后，可以看到主线程创建的五个新线程在进行打印操作后就退出了，而主线程也成功对这五个线程进行了等待。
下面我们再来看看如何获取线程退出时的退出码，我们这里将线程退出时的退出码设置为某个特殊的值，并在成功等待线程后将该线程的退出码进行输出。
#include#include #include #include #include void* Routine(void* arg) { char* msg = (char*)arg; int count = 0; printf("I am %s...pid: %d, ppid: %d, tid: %lu\n", msg, getpid(), getppid(), pthread_self()); sleep(1); return (void*)111; } int main() { pthread_t tid[5]; for (int i = 0; i < 5; i++){ char* buffer = (char*)malloc(64); sprintf(buffer, "thread %d", i); pthread_create(&tid[i], NULL, Routine, buffer); printf("%s tid is %lu\n", buffer, tid[i]); } printf("I am main thread...pid: %d, ppid: %d, tid: %lu\n", getpid(), getppid(), pthread_self()); for (int i = 0; i < 5; i++){ void* ret = NULL; pthread_join(tid[i], &ret); printf("thread %d[%lu]...quit, exitcode: %d\n", i, tid[i], (int)ret); } return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
运行代码，我们拿到了每个线程退出时的退出码信息。注意： pthread_join函数默认是以阻塞的方式进行线程等待的。
为什么线程退出时只能拿到线程的退出码？
如果我们等待的是一个进程，那么当这个进程退出时，我们可以通过wait函数或是waitpid函数的输出型参数status，获取到退出进程的退出码、退出信号以及core dump标志。
那为什么等待线程时我们只能拿到退出线程的退出码？难道线程不会出现异常吗？
线程在运行过程中当然也会出现异常，线程和进程一样，线程退出的情况也有三种：
- 代码运行完毕，结果正确。
- 代码运行完毕，结果不正确。
- 代码异常终止。
因此我们也需要考虑线程异常终止的情况，但是pthread_join函数无法获取到线程异常退出时的信息。因为线程是进程内的一个执行分支，如果进程中的某个线程崩溃了，那么整个进程也会因此而崩溃，此时我们根本没办法执行pthread_join函数，因为整个进程已经退出了。
例如，我们在线程的执行例程当中制造一个除零错误，当某一个线程执行到此处时就会崩溃，进而导致整个进程崩溃。
#include#include #include #include #include void* Routine(void* arg) { char* msg = (char*)arg; int count = 0; while (count < 5){ printf("I am %s...pid: %d, ppid: %d, tid: %lu\n", msg, getpid(), getppid(), pthread_self()); sleep(1); count++; int a = 1 / 0; //error } return (void*)2022; } int main() { pthread_t tid[5]; for (int i = 0; i < 5; i++){ char* buffer = (char*)malloc(64); sprintf(buffer, "thread %d", i); pthread_create(&tid[i], NULL, Routine, buffer); printf("%s tid is %lu\n", buffer, tid[i]); } printf("I am main thread...pid: %d, ppid: %d, tid: %lu\n", getpid(), getppid(), pthread_self()); for (int i = 0; i < 5; i++){ void* ret = NULL; pthread_join(tid[i], &ret); printf("thread %d[%lu]...quit, exitcode: %d\n", i, tid[i], (int)ret); } return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
运行代码，可以看到一旦某个线程崩溃了，整个进程也就跟着挂掉了，此时主线程连等待新线程的机会都没有，这也说明了多线程的健壮性不太强，一个进程中只要有一个线程挂掉了，那么整个进程就挂掉了。并且此时我们也不知道是由于哪一个线程崩溃导致的，我们只知道是这个进程崩溃了。所以pthread_join函数只能获取到线程正常退出时的退出码，用于判断线程的运行结果是否正确。
线程终止
如果需要只终止某个线程而不是终止整个进程，可以有三种方法：
- 从线程函数return。
- 线程可以自己调用pthread_exit函数终止自己。
- 一个线程可以调用pthread_cancel函数终止同一进程中的另一个线程。
return退出
在线程中使用return代表当前线程退出，但是在main函数中使用return代表整个进程退出，也就是说只要主线程退出了那么整个进程就退出了，此时该进程曾经申请的资源就会被释放，而其他线程会因为没有了资源，自然而然的也退出了。
pthread_exit函数
pthread_exit函数的功能就是终止线程，pthread_exit函数的函数原型如下：
void pthread_exit(void *retval);- 1
参数说明：
- retval：线程退出时的退出码信息。
说明一下：
该函数无返回值，跟进程一样，线程结束的时候无法返回它的调用者（自身）。
pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其他线程得到这个返回指针时，线程函数已经退出了。例如，在下面代码中，我们使用pthread_exit函数终止线程，并将线程的退出码设置为123。
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <pthread.h> 4 #include <unistd.h> 5 #include <sys/types.h> 6 7 void *thread_run(void *args) 8 { 9 int num=*(int*)args; 10 while(1) 11 { 12 printf("我是新线程[%d],我创建的线程ID是：%lu\n",num,pthread_self()); 13 sleep(3); 14 break; 15 } 16 pthread_exit((void*)123); 17 } 18 19 int main() 20 { 21 pthread_t tid[1]; 22 for(int i=0;i<1;i++) 23 { 24 pthread_create(tid+i,NULL,thread_run,(void*)&i); 25 sleep(1); 26 } 27 void *status=NULL; 29 30 for(int i=0;i<1;i++) 31 { 32 pthread_join(tid[i],&status); 33 } 34 35 printf("ret:%d\n",(int)status); 36 sleep(3); 37 38 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
运行代码可以看到，当线程退出时其退出码就是我们设置的123。
注意： 需要区别的是，exit函数的作用是终止进程，任何一个线程调用exit函数也代表的是整个进程终止。
pthread_cancel函数
线程是可以被取消的，我们可以使用pthread_cancel函数取消某一个线程，
pthread_cancel函数的函数原型如下：
int pthread_cancel(pthread_t thread);- 1
参数说明：
- thread：被取消线程的ID。
返回值说明：
- 线程取消成功返回0，失败返回错误码。
- 线程是可以取消自己的，取消成功的线程的退出码一般是-1。
例如在下面的代码中，新线程创建后死循环打印，然后我们让新线程在5秒后将自己取消。
7 void *thread_run(void *args) 8 { 9 int num=*(int*)args; 10 while(1) 11 { 12 printf("我是新线程[%d],我创建的线程ID是：%lu\n",num,pthread_self()); 13 sleep(2); 14 } 15 pthread_exit((void*)123); 16 } 17 18 int main() 19 { 20 pthread_t tid[1]; 21 for(int i=0;i<1;i++) 22 { 23 pthread_create(tid+i,NULL,thread_run,(void*)&i); 24 25 } 26 27 printf("wait sub thread...\n"); 28 sleep(5); 29 30 printf("cancel sub thread...\n"); 31 pthread_cancel(tid[0]); 32 33 34 void *status=NULL; 35 36 for(int i=0;i<1;i++) 37 { 38 pthread_join(tid[i],&status); 39 } 40 41 printf("ret:%d\n",(int)status); 42 sleep(3); 43 44 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
运行代码，可以看到我们新线程在5秒后退出了，其退出码不是我们设置的123而是-1，因为我们是在线程执行pthread_exit函数前将线程取消的。虽然线程可以自己取消自己，但一般不这样做，我们往往是用于一个线程取消另一个线程，比如在主线程取消新线程。
此外，新线程也是可以取消主线程的，例如下面我们新线程尝试对主线程进行取消。
1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <pthread.h> 4 #include <unistd.h> 5 #include <sys/types.h> 6 7 pthread_t main_thread; 8 9 void *thread_run(void *args) 10 { 11 int num=*(int*)args; 12 int count=0; 13 while(count<10) 14 { 15 printf("我是新线程[%d],我创建的线程ID是：%lu\n",num,pthread_self()); 16 sleep(1); 17 count++; 18 pthread_cancel(main_thread); 19 } 20 pthread_exit((void*)123); 21 } 22 23 int main() 24 { 25 main_thread = pthread_self(); 26 pthread_t tid[1]; 27 for(int i=0;i<1;i++) 28 { 29 pthread_create(tid+i,NULL,thread_run,(void*)&i); 30 sleep(1); 31 } 32 33 //printf("wait sub thread...\n"); 34 //sleep(5); 35 36 //printf("cancel sub thread...\n"); 37 //pthread_cancel(tid[0]); 38 39 40 void *status=NULL; 41 42 for(int i=0;i<1;i++) 43 { 44 pthread_join(tid[i],&status); 45 } 46 47 printf("ret:%d\n",(int)status); 48 sleep(3); 49 50 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
运行代码，同时用以下监控脚本进行实时监控。
$ while :; do ps -aL | head -1&&ps -aL | grep mythread | grep -v grep;echo "###############";sleep 1;done- 1
可以看到一段时间后，PID和LWP相同的线程，也就是主线程的右侧显示 < defunct > ，这意味着主线程已经被取消了，我们也就看不到后续主线程等待新线程时打印的退出码了。注意：
- 当采用这种取消方式时，主线程和各个新线程之间的地位是对等的，取消一个线程，其他线程也是能够跑完的，只不过主线程不再执行后续代码了。
- 我们一般都是用主线程去控制新线程，这才符合我们对线程控制的基本逻辑，虽然实验表明新线程可以取消主线程，但是并不推荐该做法。
分离线程
- 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成内存泄漏。
- 但如果我们不关心线程的返回值，join也是一种负担，此时我们可以将该线程进行分离，后续当线程退出时就会自动释放线程资源。
- 一个线程如果被分离了，这个线程依旧要使用该进程的资源，依旧在该进程内运行，甚至这个线程崩溃了一定会影响其他线程，只不过这个线程退出时不再需要主线程去join了，当这个线程退出时系统会自动回收该线程所对应的资源。
- 可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离。
- joinable和分离是冲突的，一个线程不能既是joinable又是分离的。
分离线程的函数叫做pthread_detach
pthread_detach函数的函数原型如下：
int pthread_detach(pthread_t thread);- 1
参数说明：
- thread：被分离线程的ID。
返回值说明：
- 线程分离成功返回0，失败返回错误码。
例如，下面我们创建新线程后让新线程将自己进行分离。
#include#include #include #include #include void *thread_run( void * arg ) { pthread_detach(pthread_self()); printf("%s\n", (char*)arg); return NULL; } int main( void ) { pthread_t tid; if ( pthread_create(&tid, NULL, thread_run, "thread1 run...") != 0 ) { printf("create thread error\n"); return 1; } int ret = 0; sleep(1);//很重要，要让线程先分离，再等待 if ( pthread_join(tid, NULL ) == 0 ) { printf("pthread wait success\n"); ret = 0; } else { printf("pthread wait failed\n"); ret = 1; } return ret; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
可以看到，新线程分离后，并没有进行pthread_join，也就是说此后主线程就不需要对这个新线程进行join了，这也证明了joinable和分离是冲突的，一个线程不能既是joinable又是分离的。
线程ID及进程地址空间布局
- pthread_create函数会产生一个线程ID，存放在第一个参数指向的地址中，该线程ID和内核中的LWP不是一回事。
- 内核中的LWP属于进程调度的范畴，因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。
- pthread_create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，这个ID属于NPTL线程库的范畴，线程库的后续操作就是根据该线程ID来操作线程的。
- 线程库NPTL提供的pthread_self函数，获取的线程ID和pthread_create函数第一个参数获取的线程ID是一样的。
pthread_t到底是什么类型呢？
我们知道，pthread_self它返回一个 pthread_t 类型的变量，指代的是调用 pthread_self 函数的线程的 “ID”。这个“ID”是 pthread 库给每个线程定义的进程内唯一标识，是 pthread 库维持的。由于每个进程有自己独立的内存空间，故此“ID”的作用域是进程级而非系统级(内核不认识)。
详细来说，Linux不提供真正的线程，只提供LWP，也就意味着操作系统只需要对内核执行流的LWP进行管理，而供用户使用的线程接口等其他数据，应该由线程库自己来管理，因此管理线程时的“先描述，再组织”就应该在线程库（动态库）里进行。
通过ldd命令可以看到，我们采用的线程库实际上就是一个动态库。
线程库本身也是文件，进程运行时线程库从磁盘加载到物理内存，然后通过页表映射到进程地址空间中的共享区，此时该进程内的所有线程都是能看到这个线程库的。
- 我们知道每个线程都有自己私有的栈，其中主线程采用的栈是进程地址空间中原生的栈，而其余线程采用的栈就是在共享区中开辟的。
- 除此之外，每个线程都有自己的struct pthread，当中包含了对应线程的各种属性；每个线程还有自己的线程局部存储，当中包含了对应线程被切换时的上下文数据。
- 每一个新线程在共享区都有这样一块区域对其进行描述，因此我们要找到一个用户级线程只需要找到该线程内存块的起始地址，然后就可以获取到该线程的各种信息。
我们所用的各种线程函数，本质都是在库内部对线程属性进行的各种操作，最后将要执行的代码交给对应的内核级LWP去执行就行了，也就是说线程数据的管理本质是在共享区的。
pthread_t 到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质就是一个进程地址空间上的一个地址。
例如，我们可以尝试按地址的形式对获取到的线程ID进行打印
#include#include #include void* pthread_run(void* arg) { while (1){ printf("new thread tid: %p\n", pthread_self()); sleep(1); } } int main() { pthread_t tid; pthread_create(&tid, NULL, pthread_run, NULL); while (1){ printf("main thread tid: %p\n", pthread_self()); sleep(2); } return 0; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
==============================================================
– the End –
以上就是我分享的Linux多线程相关内容，感谢阅读！
本文收录于专栏：Linux
关注作者，持续阅读作者的文章，学习更多知识！
https://blog.csdn.net/weixin_53306029?spm=1001.2014.3001.5343 -
相关阅读:
mac图像查看器EdgeView for Mac
修改禅道启动因mysql端口被占用问题
SpringBoot War打包部署
AI网络爬虫：下载m3u8视频文件
如何做到在 5 分钟之内将应用大小减少 60% 的？
React:实现一个定时器计数器，每秒自动+1
Biotin-PEG-N3 生物素PEG叠氮
【学习笔记01】node的认识和安装
Django创建模型
Ubuntu下安装node.js遇到的问题记录
- 原文地址：https://blog.csdn.net/weixin_53306029/article/details/125955578
