赞
踩
需要明确的是,一个进程的创建实际上伴随着其进程控制块(task_struct)、进程地址空间(mm_struct)以及页表的创建,虚拟地址和物理地址就是通过页表建立映射的。
此时我们创建的实际上就是四个线程:
因此,所谓的进程并不是通过task_struct来衡量的,除了task_struct之外,一个进程还要有进程地址空间、文件、信号等等,合起来称之为一个进程。
现在我们应该站在内核角度来理解进程:承担分配系统资源的基本实体,叫做进程。
换言之,当我们创建进程时是创建一个task_struct、创建地址空间、维护页表,然后在物理内存当中开辟空间、构建映射,打开进程默认打开的相关文件、注册信号对应的处理方案等等。
而我们之前接触到的进程都只有一个task_struct,也就是该进程内部只有一个执行流,即单执行流进程,反之,内部有多个执行流的进程叫做多执行流进程。
在Linux中,站在CPU的角度,能否识别当前调度的task_struct是进程还是线程?
不能,也不需要了,因为CPU只关心一个一个的独立执行流。无论进程内部只有一个执行流还是有多个执行流,CPU都是以task_struct为单位进行调度的。
Linux下并不存在真正的多线程!而是用进程模拟的!
操作系统中存在大量的进程,一个进程内又存在一个或多个线程,因此线程的数量一定比进程的数量多,当线程的数量足够多的时候,很明显线程的执行粒度要比进程更细。
如果一款操作系统要支持真的线程,那么就需要对这些线程进行管理。比如说创建线程、终止线程、调度线程、切换线程、给线程分配资源、释放资源以及回收资源等等,所有的这一套相比较进程都需要另起炉灶,搭建一套与进程平行的线程管理模块。
因此,如果要支持真的线程一定会提高设计操作系统的复杂程度。在Linux看来,描述线程的控制块和描述进程的控制块是类似的,因此Linux并没有重新为线程设计数据结构,而是直接复用了进程控制块,所以我们说Linux中的所有执行流都叫做轻量级进程。
但也有支持真的线程的操作系统,比如Windows操作系统,因此Windows操作系统系统的实现逻辑一定比Linux操作系统的实现逻辑要复杂得多。
既然在Linux没有真正意义的线程,那么也就绝对没有真正意义上的线程相关的系统调用!
这很好理解,既然在Linux中都没有真正意义上的线程了,那么自然也没有真正意义上的线程相关的系统调用了。但是Linux可以提供创建轻量级进程的接口,也就是创建进程,共享空间,其中最典型的代表就是vfork函数。
vfork函数的功能就是创建子进程,但是父子共享空间,v函数fork的函数原型如下:
pid_t vfork(void);
vfork函数的返回值与fork函数的返回值相同:
只不过vfork函数创建出来的子进程与其父进程共享地址空间,例如在下面的代码中,父进程使用vfork函数创建子进程,子进程将全局变量g_val由233改为了666,父进程休眠3秒后再读取到全局变量g_val的值。
#include<unistd.h> #include<cstdlib> #include<iostream> #include<sys/types.h> int g_val=233; int main() { pid_t id=vfork(); if(id==0) { g_val=666; std::cout<<"g_val被我改变了,现在是这个值: "<<g_val<<std::endl; exit(0); } sleep(3); std::cout<<"我是父进程 g_val现在是: "<<g_val<<std::endl; return 0; }
原生线程库pthread
在Linux中,站在内核角度没有真正意义上线程相关的接口,但是站在用户角度,当用户想创建一个线程时更期望使用thread_create这样类似的接口,而不是vfork函数,因此系统为用户层提供了原生线程库pthread。
原生线程库实际就是对轻量级进程的系统调用进行了封装,在用户层模拟实现了一套线程相关的接口。
因此对于我们来讲,在Linux下学习线程实际上就是学习在用户层模拟实现的这一套接口,而并非操作系统的接口。
以32位平台为例,在32位平台下一共有232个地址,也就意味着有232个地址需要被映射。
如果我们所谓的页表就只是单纯的一张表,那么这张表就需要建立232个虚拟地址和物理地址之间的映射关系,即这张表一共有232个映射表项。
每一个表项中除了要有虚拟地址和与其映射的物理地址以外,实际还需要有一些权限相关的信息,比如我们所说的用户级页表和内核级页表,实际就是通过权限进行区分的。
每个应表项中存储一个物理地址和一个虚拟地址就需要8个字节,考虑到还需要包含权限相关的各种信息,这里每一个表项就按10个字节计算。
这里一共有232个表项,也就意味着存储这张页表我们需要用232 * 10个字节,也就是40GB。而在32位平台下我们的内存可能一共就只有4GB,也就是说我们根本无法存储这样的一张页表。
因此所谓的页表并不是单纯的一张表。
还是以32位平台为例,其页表的映射过程如下:
相关说明:
这实际上就是我们所谓的二级页表,其中页目录项是一级页表,页表项是二级页表。
每一个表项还是按10字节计算,页目录和页表的表项都是210个,因此一个表的大小就是210 * 10个字节,也就是10KB。而页目录有210个表项也就意味着页表有210个,也就是说一级页表有1张,二级页表有210张,总共算下来大概就是10MB,内存消耗并不高,因此Linux中实际就是这样映射的。
上面所说的所有映射过程,都是由MMU(MemoryManagementUnit)这个硬件完成的,该硬件是集成在CPU内的。页表是一种软件映射,MMU是一种硬件映射,所以计算机进行虚拟地址到物理地址的转化采用的是软硬件结合的方式。
注意: 在Linux中,32位平台下用的是二级页表,而64位平台下用的是多级页表。
修改常量字符串为什么会触发段错误?
当我们要修改一个字符串常量时,虚拟地址必须经过页表映射找到对应的物理内存,而在查表过程中发现其权限是只读的,此时你要对其进行修改就会在MMU内部触发硬件错误,操作系统在识别到是哪一个进程导致的之后,就会给该进程发送信号对其进行终止。
概念说明:
进程是承担分配系统资源的基本实体,线程是调度的基本单位。
线程共享进程数据,但也拥有自己的一部分数据:
因为是在同一个地址空间,因此所谓的代码段(Text Segment)、数据段(Data Segment)都是共享的:
除此之外,各线程还共享以下进程资源和环境:
进程和线程的关系如下图:
在此之前我们接触到的都是具有一个线程执行流的进程,即单线程进程。
pthread线程库是应用层的原生线程库:
错误检查:
创建线程的函数叫做pthread_create
pthread_create函数的函数原型如下:
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
参数说明:
返回值说明:
让主线程创建一个新线程
当一个程序启动时,就有一个进程被操作系统创建,与此同时一个线程也立刻运行,这个线程就叫做主线程。
下面我们让主线程调用pthread_create函数创建一个新线程,此后新线程就会跑去执行自己的新例程,而主线程则继续执行后续代码。
#include<unistd.h> #include<cstdlib> #include<iostream> #include<sys/types.h> #include<pthread.h> void* Routine(void* arg) { char* name= (char*)arg; while (true) { std::cout<<"我是 "<<name<<std::endl; sleep(2); } } int main() { pthread_t t1; pthread_create(&t1,nullptr,Routine,(void*)"thread 1"); while(true) { std::cout<<"我是 main thread"<<std::endl; sleep(1); } return 0; }
当我们用ps axj命令查看当前进程的信息时,虽然此时该进程中有两个线程,但是我们看到的进程只有一个,因为这两个线程都是属于同一个进程的。
使用 ps -aL 命令,可以显示当前的轻量级进程。
其中,LWP(Light Weight Process)就是轻量级进程的ID,可以看到显示的两个轻量级进程的PID是相同的,因为它们属于同一个进程。
注意: 在Linux中,应用层的线程与内核的LWP是一一对应的,实际上操作系统调度的时候采用的是LWP,而并非PID,只不过我们之前接触到的都是单线程进程,其PID和LWP是相等的,所以对于单线程进程来说,调度时采用PID和LWP是一样的。
为了进一步证明这两个线程是属于同一个进程的,我们可以让主线程和新线程在执行打印操作时,将自己的PID和PPID也进行打印。
#include <stdio.h> #include <pthread.h> #include <unistd.h> #include <sys/types.h> void* Routine(void* arg) { char* msg = (char*)arg; while (1){ printf("I am %s...pid: %d, ppid: %d\n", msg, getpid(), getppid()); sleep(1); } } int main() { pthread_t tid; pthread_create(&tid, NULL, Routine, (void*)"thread 1"); while (1){ printf("I am main thread...pid: %d, ppid: %d\n", getpid(), getppid()); sleep(2); } return 0; }
让主线程创建一批新线程
上面是让主线程创建一个新线程,下面我们让主线程一次性创建五个新线程,并让创建的每一个新线程都去执行Routine函数,也就是说Routine函数会被重复进入,即该函数是会被重入的。
#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> #include <sys/types.h> void* Routine(void* arg) { char* msg = (char*)arg; while (1){ printf("I am %s...pid: %d, ppid: %d\n", msg, getpid(), getppid()); sleep(1); } } 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); } while (1){ printf("I am main thread...pid: %d, ppid: %d\n", getpid(), getppid()); sleep(2); } return 0; }
运行代码,可以看到这五个新线程是创建成功的。
因为主线程和五个新线程都属于同一个进程,所以它们的PID和PPID也都是一样的。
此时我们再用ps -aL命令查看,就会看到六个轻量级进程。
获取线程ID
常见获取线程ID的方式有两种:
pthread_self函数的函数原型如下:
pthread_t pthread_self(void);
调用pthread_self函数即可获得当前线程的ID,类似于调用getpid函数获取当前进程的ID。
例如,下面代码中在每一个新线程被创建后,主线程都将通过输出型参数获取到的线程ID进行打印,此后主线程和新线程又通过调用pthread_self函数获取到自身的线程ID进行打印。
#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> #include <sys/types.h> void* Routine(void* arg) { char* msg = (char*)arg; while (1){ printf("I am %s...pid: %d, ppid: %d, tid: %lu\n", msg, getpid(), getppid(), pthread_self()); sleep(1); } } 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]); } while (1){ printf("I am main thread...pid: %d, ppid: %d, tid: %lu\n", getpid(), getppid(), pthread_self()); sleep(2); } return 0; }
运行代码,可以看到这两种方式获取到的线程的ID是一样的。
注意: 用pthread_self函数获得的线程ID与内核的LWP的值是不相等的,pthread_self函数获得的是用户级原生线程库的线程ID,而LWP是内核的轻量级进程ID,它们之间是一对一的关系。
首先需要明确的是,一个线程被创建出来,这个线程就如同进程一般,也是需要被等待的。如果主线程不对新线程进行等待,那么这个新线程的资源也是不会被回收的。所以线程需要被等待,如果不等待会产生类似于“僵尸进程”的问题,也就是内存泄漏。
等待线程的函数叫做pthread_join
pthread_join函数的函数原型如下:
int pthread_join(pthread_t thread, void **retval);
参数说明:
返回值说明:
调用该函数的线程将挂起等待,直到ID为thread的线程终止,thread线程以不同的方法终止,通过pthread_join得到的终止状态是不同的。
总结如下:
用grep命令进行查找,可以发现PTHREAD_CANCELED实际上就是头文件<pthread.h>里面的一个宏定义,它的值本质就是-1。
[cl@VM-0-15-centos thread]$ grep -ER "PTHREAD_CANCELED" /usr/include/
例如,在下面的代码中我们先不关心线程的退出信息,直接将pthread_join函数的第二次参数设置为NULL,等待线程后打印该线程的编号以及线程ID。
#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> #include <sys/types.h> 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++; } 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; }
运行代码后,可以看到主线程创建的五个新线程在进行五次打印操作后就退出了,而主线程也是成功对这五个线程进行了等待。
下面我们再来看看如何获取线程退出时的退出码,为了便于查看,我们这里将线程退出时的退出码设置为某个特殊的值,并在成功等待线程后将该线程的退出码进行输出。
#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> #include <sys/types.h> 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++; } 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; }
注意: pthread_join函数默认是以阻塞的方式进行线程等待的。
为什么线程退出时只能拿到线程的退出码?
如果我们等待的是一个进程,那么当这个进程退出时,我们可以通过wait函数或是waitpid函数的输出型参数status,获取到退出进程的退出码、退出信号以及core dump标志。
那为什么等待线程时我们只能拿到退出线程的退出码?难道线程不会出现异常吗?
线程在运行过程中当然也会出现异常,线程和进程一样,线程退出的情况也有三种:
因此我们也需要考虑线程异常终止的情况,但是pthread_join函数无法获取到线程异常退出时的信息。因为线程是进程内的一个执行分支,如果进程中的某个线程崩溃了,那么整个进程也会因此而崩溃,此时我们根本没办法执行pthread_join函数,因为整个进程已经退出了。
例如,我们在线程的执行例程当中制造一个除零错误,当某一个线程执行到此处时就会崩溃,进而导致整个进程崩溃。
#include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <unistd.h> #include <sys/types.h> 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; }
所以pthread_join函数只能获取到线程正常退出时的退出码,用于判断线程的运行结果是否正确。
如果需要只终止某个线程而不是终止整个进程,可以有三种方法:
在线程中使用return代表当前线程退出,但是在main函数中使用return代表整个进程退出,也就是说只要主线程退出了那么整个进程就退出了,此时该进程曾经申请的资源就会被释放,而其他线程会因为没有了资源,自然而然的也退出了。
pthread_exit函数
pthread_exit函数的功能就是终止线程,pthread_exit函数的函数原型如下:
void pthread_exit(void *retval);
参数说明:
说明一下:
注意: exit函数的作用是终止进程,任何一个线程调用exit函数也代表的是整个进程终止
pthread_cancel函数
线程是可以被取消的,我们可以使用pthread_cancel函数取消某一个线程,pthread_cancel函数的函数原型如下:
int pthread_cancel(pthread_t thread);
参数说明:
返回值说明:
线程是可以取消自己的,取消成功的线程的退出码一般是-1。例如在下面的代码中,我们让线程执行一次打印操作后将自己取消。
虽然线程可以自己取消自己,但一般不这样做,我们往往是用于一个线程取消另一个线程,比如主线程取消新线程.
此外,新线程也是可以取消主线程的
注意:
分离线程的函数叫做pthread_detach
pthread_detach函数的函数原型如下:
int pthread_detach(pthread_t thread);
参数说明:
返回值说明:
例如,我们创建五个新线程后让这五个新线程将自己进行分离,那么此后主线程就不需要在对这五个新线程进行join了。
Copyright © 2003-2013 www.wpsshop.cn 版权所有,并保留所有权利。