Linux多线程文章目录一. 线程概念以往创建进程会创建 task_struct，mm_struct，页表等，但如果

文章目录一. 线程概念以往创建进程会创建 task_struct，mm_struct，页表等，但如果创建 “进程” 只能创建 task_struct，不能创建 mm_struct，页表等，且创建出来的 task_struct 和父进程共享进程地址空间，页表等，这些"进程"被称作线程

在Linux中，站在CPU的角度，不能识别 task_struct 是进程还是线程，因为CPU只关心一个一个的独立执行流

进程 : 站在内核角度，承担分配系统资源的基本实体

我们之前所认识的进程都是只有一个 task_struct，也就是说进程只有一个执行流

Linux下，并不存在真正的多线程，如果支持真的线程，当线程足够多的时候，OS一定是要管理线程的，这样会提高设计OS的复杂程度，所以线程直接复用了进程的 task_struct ，即线程是用进程模拟出来的，Linux下的所有执行流，都叫做轻量级进程

Linux并没有真正意义上的线程，所以Linux也没有线程相关的系统调用，但会提供创建线程的接口(vfork() : 创建进程，父子共享空间)，在用户角度，可以使用原生线程库来解决

分页存储 :

将内存空间分为一个个大小相等的分区(例如每个分区4KB)，每个分区为一个页框/页帧/内存块/物理块/物理页面，每个页框有一个编号，即页框号/页帧号/内存块号/物理块号/物理页号，页框号从0开始

进程地址空间也分为与页框大小相等的一个个部分，每一部分称为页/页面，每个页面也有一个编号，即页号，页号也从0开始

页表 : 由一个个页表项组成，每个页表项由"页号"和"块号"组成

单级页表将逻辑地址转换成物理地址的步骤（页面大小为4KB，页表项为4B）:

(1). 逻辑地址/4KB得到逻辑地址所处的页面

(2). 逻辑地址 % 4KB 得到页内偏移量

(3). 查询页表得到对应的内存块号，内存块号 * 4KB + 页内偏移量得到物理地址

单级页表存在的问题 :

某计算机系统按字节寻址，支持32位的逻辑地址，采用分页存储管理，因为页面的大小固定为 4KB = 2^12B，所以前12位表示页内偏移量，后20位为页号，系统中最多有2 ^20个页面，页表项为4B，则页表所需要的内存空间为 2 ^20 * 4B = 2 ^22B = 4MB

二级页表 :

系统最多有2^20个页面，对应页表项有2 ^20个，每个页表项为4B，我们可以将2 ^10个页表项为一组，这样一组页表项的大小为 2 ^10 * 4B = 2 ^12B = 4KB，正好可以放到一个页框中，将其分为2 ^

10组，维护一个页目录表，用来记录每组的内存块号，页目录表的大小 2 ^10 * 4B = 2^12B = 4KB

二级页表将逻辑地址转换成物理地址的步骤（页面大小为4KB，页表项为4B）:

(1). 将逻辑地址分为3部分，根据后10位找到对应内存块的二级页表

(2). 根据中10位找到逻辑地址对应物理地址的起始地址

(3). 根据前12位得到偏移量，由第二步得到的起始地址 + 偏移量得到最终的物理地址

// 为什么不能改? const char* msg = "hello world\n"; *msg = 'H'; 页表里还有是否命中，权限等选项，前面说过页表也分为内核级页表和用户级页表，但不是物理上分开，而是通过权限分开的，页表中有RWX（读写可执行）权限，访问字符串时，需要访问页表得到物理地址，但RWX权限是只R的，写入会触发MMU硬件错误，操作系统识别到该硬件错误向该进程发送信号使进程终止

缺页中断 : 如果在访问期间，目标资源不在内存中，则会触发缺页中断，进行内存分配，页面换入，建立映射，在调用malloc,new时，只是在堆区空间开辟出来，也就是只给了你虚拟地址，当访问时，发现物理内存还没分配，操作系统会申请一块内存，然后进行虚拟地址和物理地址的映射，这种现象就叫做由于缺页中断引起的内存分配的现象

线程的优点 :

(1). 创建一个新线程的代价要比创建一个新进程小得多

创建进程要创建task_struct，mm_struct，页表等数据结构(所以创建进程本质上是系统不断的分配资源)，而创建线程只需要创建出一个task_struct以及少量的数据结构，只需要分配进程的资源即可

(2). 与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多

进程的切换需要涉及到切换task_struct，mm_struct，页表，上下文信息等等，而线程切换只需要切换上下文即可

(3). 线程占用的资源要比进程少很多

(4). 在等待慢速IO操作结束的同时，程序可执行其他的计算任务(迅雷边下边播的功能就是用多线程实现的)

(5). 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现

计算密集型 : 执行流的大部分任务，主要以计算为主 : 加密解密，排序查找

(6). I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作。

I/O密集型 : 执行流的大部分任务，是以I/O为主的 : 刷磁盘，访问数据库，访问网络(百度网盘上传和下载)

线程的缺点 :

(1). 性能损失

一个很少被外部事件阻塞的计算密集型线程往往无法与共它线程共享同一个处理器。如果计算密集型

线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的

同步和调度开销，而可用的资源不变。

(2). 健壮性降低

因为进程运行是具有独立性的，所以一个进程挂了不会影响另一个进程，而多线程地址空间共享，也就意味着通过地址空间，多线程看到的资源大部分是相同的，一个线程崩溃了，其他线程也会崩溃，进程也就随之崩溃了

(3). 缺乏访问控制

进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。

进程 vs 线程

(1). 进程是资源分配的基本单位，线程是调度的基本单位

(2). 线程共享进程数据，但也有自己的一部分数据

线程ID

一组寄存器(线程上下文数据)

栈

errno

信号屏蔽字

调度优先级

寄存器保存线程的上下文信息

线程运行时会产生各种临时数据，需要将数据进行压栈

进程的多个线程共享

同一地址空间，因此Text Segment，Data Segment 都是共享的，如果定义一个函数，在各线程中都可以调用，如果定义一个全局变量，各线程都可以访问到，除此之外，各线程还共享以下进程资源和环境

文件描述符表

每种信号的处理方式(SIG_IGN，SIG_DFL，或自定义处理函数)

当前工作目录

用户id和组id

功能：创建一个新的线程原型 int pthread_create(pthread_t *thread, const pthread_attr_t attr, void * (start_routine)(void), void arg); 参数: pthread_t : 无符号长整型 thread:返回线程ID attr:设置线程的属性，attr为NULL表示使用默认属性 start_routine:是个函数地址，线程启动后要执行的函数 arg:传给线程启动函数的参数返回值：成功返回0，失败返回错误码 #include<stdio.h> #include<sys/types.h> #include<unistd.h> #include<pthread.h> void Routine(void arg) {

    while(1)
    {

            printf(" %s :  pid : %d,ppid : %d\n ",(char*)arg,getpid(),getppid());
            sleep(1);
    }

} int main() {

    pthread_t tid;
    pthread_create(&tid,NULL,Routine,(void*)"thread 1");
    while(1)
    {

            printf("main thread , pid : %d,ppid : %d\n",getpid(),getppid());
            sleep(1);
    }
    return 0;

}

主线程和新创建的线程进程pid和ppid都是一样的，可以看出虽然这是两个线程，但是这两个线程同属于一个进程

我们可以使用 ps -aL 命令来查看线程

ps -aL | head -1 && ps -aL | grep mythread -L : 显示当前的轻量级进程

所以实际上，操作系统调度的时候，根本看的不是进程pid，而是LWP(light weight process)

pthread_t pthread_self(void); 功能 : 可以获得线程自身的ID #include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<unistd.h> #include<pthread.h> void* Routine(void* arg) {

    while(1)
    {

            printf(" %s :  pid : %d,ppid : %d,tid : %lu\n ",(char*)arg,getpid(),getppid(),pthread_self());
            sleep(1);
    }

} int main() {

    pthread_t tid[5];
    for(int i = 0;i < 5;i++)
    {

            char* buffer = malloc(64);
            sprintf(buffer,"thread %d",i);
            pthread_create(&tid[i],NULL,Routine,(void*)buffer);
            printf("%s tid : %lu\n",buffer,tid[i]);
    }
    while(1)
    {

            printf("main thread , pid : %d,ppid : %d,tid : %lu\n",getpid(),getppid(),pthread_self());
            sleep(1);
    }
    return 0;

}

pthread_self()获得的是用户级原生线程库的线程 id，LWP是内核的轻量级进程id，这两个id是有对应关系的(1 : 1)，一个用户级原生线程库的线程 id 对应 LWP 的某个值

原型 int pthread_join(pthread_t thread, void value_ptr); 功能：等待线程结束(阻塞式等待) 参数 thread:线程ID value_ptr:它指向一个指针，后者指向线程的返回值返回值：成功返回0；失败返回错误码 #include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<unistd.h> #include<pthread.h> void Routine(void arg) {

    int count = 0;
    while(count < 5)
    {

            printf("%s :  pid : %d,ppid : %d,tid : %lu\n ",(char*)arg,getpid(),getppid(),pthread_self());
            sleep(1);
            count++;
    }
    return (void*)0; // (void*)10

} 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,(void*)buffer);
            printf("%s tid : %lu\n",buffer,tid[i]);
    }
    printf("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,code : %d\n",i,tid[i],(int)ret);
    }
    return 0;

}

线程终止 :

(1). return XXX 终止线程，但如果在main函数中return XXX，会导致进程退出，所有线程退出

(2). 在线程中使用 pthread_exit(void *value_ptr)，用来终止某个线程，调用 exit() 会导致进程退出

(3). 使用 pthread_cancel(pthread_t thread)取消某个线程

原型 void pthread_exit(void *value_ptr); 功能：线程终止参数 : value_ptr : 线程退出的退出码返回值：无返回值，跟进程一样，线程结束的时候无法返回到它的调用者（自身）原型 int pthread_cancel(pthread_t thread); 功能：取消一个执行中的线程参数 thread:线程ID 返回值：成功返回0；失败返回错误码 exit : 终止进程，在线程中使用exit()，会使进程直接退出，从而不会再执行 printf(“thread %d[%lu]…quit,code : %d\n”,i,tid[i],(int)ret);

#include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<unistd.h> #include<pthread.h> void* Routine(void* arg) {

    int count = 0;
    while(count < 5)
    {

            printf("%s :  pid : %d,ppid : %d,tid : %lu\n ",(char*)arg,getpid(),getppid(),pthread_self());
            sleep(1);
            count++;
    }
   exit(0);

} 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,(void*)buffer);
            printf("%s tid : %lu\n",buffer,tid[i]);
    }
    printf("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,code : %d\n",i,tid[i],(int)ret);
    }
    return 0;

}

#include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<unistd.h> #include<pthread.h> void* Routine(void* arg) {

    int count = 0;
    while(count < 5)
    {

            printf("%s :  pid : %d,ppid : %d,tid : %lu\n ",(char*)arg,getpid(),getppid(),pthread_self());
            sleep(1);
            count++;
    }
    pthread_exit((void*)10);

} 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,(void*)buffer);
            printf("%s tid : %lu\n",buffer,tid[i]);
    }
    printf("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,code : %d\n",i,tid[i],(int)ret);
    }
    return 0;

}

(1). 自已取消自己的时候最好后面还有代码，取消线程成功，退出码为 -1 (如果取消线程后面没有代码，返回值为0)

(2). 推荐在主线程中取消其他线程

#include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<unistd.h> #include<pthread.h> void* Routine(void* arg) {

    int count = 0;
    while(count < 5)
    {

            printf("%s :  pid : %d,ppid : %d,tid : %lu\n ",(char*)arg,getpid(),getppid(),pthread_self());
            sleep(1);
            count++;
    }
    pthread_exit((void*)10);

} 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,(void*)buffer);
            printf("%s tid : %lu\n",buffer,tid[i]);
    }
    printf("main thread , pid : %d,ppid : %d,tid : %lu\n",getpid(),getppid(),pthread_self());
	pthread_cancel(tid[0]);
	pthread_cancel(tid[1]);
    for(int i = 0;i < 5;i++)
    {

    		void* ret = NULL;
            pthread_join(tid[i],&ret);
            printf("thread %d[%lu]....quit,code : %d\n",i,tid[i],(int)ret);
    }
    return 0;

}

一般情况下，线程必须被等待，就如同子进程必须被等待一般，但是线程也可以不被等待，不过需要将线程进行分离

线程分离 : 一个线程被分离了，这个线程依旧会使用进程的资源，只不过这个线程是不需要主线程去等待的，如果这个线程退出了，系统会自动回收该线程的资源，不需要通过主线程去等待了(建议自己分离自己)

#include <pthread.h> int pthread_detach(pthread_t thread); 功能 : 进行线程分离返回值 : 成功返回0，失败返回错误码 #include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<unistd.h> #include<pthread.h> void* Routine(void* arg) {

    pthread_detach(pthread_self());
    int count = 0;
    while(count < 5)
    {

            printf("%s :  pid : %d,ppid : %d,tid : %lu\n ",(char*)arg,getpid(),getppid(),pthread_self());
            sleep(1);
            count++;
    }
    pthread_exit((void*)10);

} 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,(void*)buffer);
            printf("%s tid : %lu\n",buffer,tid[i]);
    }
    printf("main thread , pid : %d,ppid : %d,tid : %lu\n",getpid(),getppid(),pthread_self());

    while(1)
    {

} return 0; }

while : ;do ps -aL |head -1 && ps -aL | grep mythread; echo "##################"; sleep 1; done #include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<unistd.h> #include<pthread.h> void* Routine(void* arg) {

    while(1)
    {

            printf("new thread : %p\n",pthread_self());
            sleep(1);
    }

} int main() {

    pthread_t tid;
    pthread_create(&tid,NULL,Routine,NULL);
    while(1)
    {

            printf("main thread id : %p\n",pthread_self());
            sleep(2);
    }
    pthread_join(tid,NULL);

}

线程有很多，所以线程是需要被管理的，OS管理资源采用先描述再组织的方式，而Linux不存在真正意义上的多线程，只提供了LWP，OS只需要对LWP内核执行流进行管理，给用户使用的接口等其他数据，是由线程库pthread库来管理

pthread库是一个普通文件，运行起mythread程序，程序所依赖的pthread库被加载到内存中，映射到进程地址空间中的共享区，这样每一个线程都能看到pthread库

主线程使用进程的栈，而线程所私有的栈，寄存器等是在动态库中，如果要找到一个线程，只需要找到描述该线程的内存块的起始地址，线程的相关属性就可以被找到了

所谓的线程id本质上是一个地址，一个映射到pthread库中特定内存块的虚拟共享区地址

线程切换并不需要去执行内核代码来完成切换，只需要去动态库中把当前线程的临时数据保存到栈中，上下文信息保存到寄存器中，切换到下一个线程控制块，把下一个线程的相关信息交给CPU执行即可

有缺陷的抢票系统

#include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<unistd.h> #include<pthread.h> int tickets = 2000; void* TicketGrabbing(void* name) {

    while(1)
    {

            if(tickets > 0)
            {

                    usleep(100);
                    printf("[%s] got a tickets : %d\n",name,tickets--);
            }
            else
            {

                    break;
            }
    }
    printf("%s quit\n",name);
    pthread_exit((void*)0);

} int main() {

    pthread_t t1,t2,t3,t4;
    pthread_create(&t1,NULL,TicketGrabbing,"thread 1");
    pthread_create(&t2,NULL,TicketGrabbing,"thread 2");
    pthread_create(&t3,NULL,TicketGrabbing,"thread 3");
    pthread_create(&t4,NULL,TicketGrabbing,"thread 4");
	
	pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    pthread_join(t3,NULL);
    pthread_join(t4,NULL);

    return 0;

}

上述代码的4个线程同时访问的 tickets 就是临界资源，访问 tickets 的代码称为临界区

tickets- - 至少需要进行三步操作

(1). 将 tickets 的值读到CPU的寄存器中

(2). 将寄存器中的值 - -

(3). 最后将寄存器中的值写回 tickets 中

tickets- - 不是原子操作

这就会导致问题的出现 : 线程1刚把 tickets 的值 1000 读到寄存器中，有可能就被切换下去了(切换下去之前要先把上下文信息保存到私有寄存器中，临时数据保存到私有栈中)，线程2开始执行，对 tickets 1000 进行- -，线程2优先级较高，直接将 tickets 减到了 900 ，线程1再次被执行，将寄存器中的1000减到999，写回 tickets 中，相当于无缘无故多出来 99 张票

tickets > 0 不是原子操作

线程1检测到 tickets 1000 > 0 进入循环后，被切换走，线程2检测到 tickets 1000 > 0 进入循环后，将 tickets 减到 0，线程1再次被执行，将 tickets 减到 -1

出现问题的本质是多个线程共同访问临界区导致的，所以我们需要保证临界区的安全，我们就需要用互斥来完成，当一个线程进入临界区执行的时候，不允许其他的线程进入，要做到这点，本质上就是需要一把锁。Linux上提供的这把锁叫互斥量，申请锁的时候如果锁已经被别人占了，那么当前线程必须等待，直到别人把锁释放才能申请到锁来访问临界区

在大部分情况下，加锁本身是有损于性能的，原来多线程可以并发或并行的去执行某种任务，现在因为多线程访问了临界资源，每一个线程在访问临界资源时都需要申请锁，申请锁成功后才能进入临界区，所以我们要尽可能地减少加锁带来的性能开销成本

加锁后的原子性体现在两方面如下

(1). 如果线程1申请了锁，线程2，线程3，线程4就会阻塞等待线程1释放锁，所以对于线程2，线程3，线程4来说，只有线程1没有申请锁或线程1释放锁后才有意义，站在线程2，线程3，线程4的视角来看是原子的

(2). 线程1在临界区内可以进行线程切换，但其他线程也无法进入临界区，因为线程1并没有释放锁，所以其他线程无法进入临界区

锁本身也是临界资源，因此申请锁的过程必须是原子的，即一个线程申请到锁，其他线程不可能再申请到锁