Linux多线程

0402嵌入式学习笔记 (18) 消息队列/创建线程 void *arg:线程参数 消息队列:传送有格式的消息流 多进程网状交叉通信,实现大规模数据通信 使用内核中的链表(实现机制) posix的消息队列和系统V消息队列区别: 消息队列是随内核随机的 线程 什么是线程 线程是进程的一个实体,它是程序运行的最小单位 为什么要学习线程 1、线程是进程的一个实体,它是程序运行的最小单位,它比进程要消耗更少的资源 2、能共享地址空间(进程)(堆栈:程序栈) 线程由哪些组成 1、指令指针 2、一个栈(函数栈) 3、寄存器的集合(状态寄存器:一部分正在运行中的处理器的状态) 4、一个私有的数据区 线程 阅读详情

文章目录

一. 线程概念

以往创建进程会创建 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并没有释放锁,所以其他线程无法进入临界区

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

#include<pthread.h>
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
参数 :
mutex:要初始化的互斥量 
attr : 互斥锁的属性,不关心设置为NULL(默认属性)
返回值 : 成功返回0,失败设置错误码
#include<pthraed.h>
int pthread_mutex_lock(pthread_mutex_t *mutex); 
int pthread_mutex_unlock(pthread_mutex_t *mutex); 
返回值:成功返回0,失败返回错误号
#include<pthread.h>
int pthread_mutex_destroy(pthread_mutex_t *mutex);
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include<pthread.h>
#define NUM 10000
int tickets = NUM;
pthread_mutex_t lock;
void* GetTickets(void* arg)
{
 
        while(1)
        {
 
                pthread_mutex_lock(&lock);
                if(tickets > 0)
                {
 
                        usleep(100);
                        printf("thread %d got a ticket: %d\n",(int)arg,tickets--);
                        pthread_mutex_unlock(&lock);
                }
                else
                {
 
                        pthread_mutex_unlock(&lock);
                        break;
                }
        }
}
int main()
{
 
        pthread_t tid[5];
        pthread_mutex_init(&lock,NULL);
        for(int i = 0;i < 5;i++) pthread_create(&tid[i],NULL,GetTickets,(void*)i);
        for(int i = 0;i < 5;i++) pthread_join(tid[i],NULL);
		pthread_mutex_destroy(&lock);
        return 0;
}

锁的原子性,是如何实现的? lock 和 ulock 的具体过程是怎样的呢?

(1). 经过上面的例子,我们已经知道 i++ 或者 ++i 都不是原子的,有可能会有数据一致性问题

(2). 为了实现互斥锁操作,大多数体系结构都提供了swap或exchange指令,该指令的作用是把寄存器和内存单元的数据相交换,由于只有一条指令,保证了原子性,即使是多处理器平台,访问内存的总线周期也有先后,一个处理器上的交换指令执行时另一个处理器的交换指令只能等待总线周期。lock和unlock的

伪代码如下

(1). 在内存中申请一个全局变量 mutex,将 mutex 的值置为1,线程A先将CPU的 al 寄存器值置为0,再将 al 寄存器和内存中的mutex的值进行交换(al寄存器中的值为1,mutex中的值为0),此时A就完成了加锁

(2). 如果线程A在执行交换指令后被切换(切换时会把CPU al 寄存器的内容保存到线程A私有的寄存器中,数据保存到线程A私有的栈中),线程B开始执行,将 al 寄存器值置为0,然后交换 al 寄存器和内存中 mutex 的值,但交换后 al 的寄存器仍然为0,因此B就会挂起等待,直到A解锁后将mutex值置为1,唤醒线程B,再次交换 al 寄存器和内存中 mutex 的值,B就完成了加锁

时钟中断是操作系统能够进行线程调度的基础,操作系统会在每次时钟中断时被唤醒,执行中断向量表,将程序流程转向中断服务程序的入口地址

线程安全:多个线程并发同一段代码时,不会出现不同的结果。常见对全局变量或者静态变量进行操作,并且没有锁保护的情况下,会导致线程不安全

重入:同一个函数被不同的执行流调用,当前一个流程还没有执行完,就有其他的执行流再次进入,我们称之为重入。一个函数在重入的情况下,运行结果不会出现任何不同或者任何问题,则该函数被称为可重入函数,否则,是不可重入函数。

(1). 线程安全描述的是线程执行代码时是否安全的情况,重入重点是函数被重复进入

常见线程不安全的情况

(1). 不保护共享变量的函数(最开始抢票代码中的抢票函数没有对 tickets 进行保护)

(2). 函数状态随着被调用,状态发生变化的函数

(3). 返回指向静态变量指针的函数

(4). 调用线程不安全函数的函数

可重入函数是线程安全函数的一种

线程安全不一定是可重入的,而可重入函数则一定是线程安全的。

如果将对临界资源的访问加上锁,则这个函数是线程安全的,但如果这个重入函数若锁还未释放则会产生死锁,因此是不可重入的(并一定多线程才会导致重入,在单执行流的情况下也可能会导致重入,如信号捕捉,如果在主线程中申请了锁,然后在执行信号处理函数中再次申请锁,就会导致死锁)

死锁

死锁是指在一组进程中的各个进程均占有不会释放的资源,但因互相申请被其他进程所站用不会释放的资源而处于的一种永久等待状态

什么叫做阻塞?

系统中有一个运行等待队列,CPU会去执行在运行等待队列中的线程

线程在等待锁或其他资源(磁盘,网卡,显示器,打印机)时,会把该线程从运行等待队列链接到资源等待队列中(由R状态设置为S状态,这种情况可以称之为该线程被挂起等待了),当锁或其他资源就绪之后,将该线程由资源等待队列中链接到运行等待队列中(由S状态设置为R状态),等待被调度

进程线程等待某种资源,在OS层面就是将进程线程的task_struct放入对应的等待队列里(R->S),这种情况就被称为进程线程被挂起等待了

死锁四个必要条件

互斥条件:一个资源每次只能被一个执行流使用

请求与保持条件:一个执行流因请求资源而阻塞时,对已获得的资源保持不放

不剥夺条件:一个执行流已获得的资源,在未使用完之前,不能强行剥夺

循环等待条件:若干执行流之间形成一种头尾相接的循环等待资源的关系

为什么要存在同步?

单纯的加锁有没有问题?

个别线程竞争力很强,每次都能申请到锁,但是不办事情,有可能导致其他线程长时间竞争不到锁,从而引起饥饿问题

举例说明 : 一间教室只允许一个学生上自习,一个学生拿着锁进了教室,把教室锁上,开始在教室上自习,其他学生想要上自习只能等待该学生上完自习后把锁拿出来,该学生上完自习了,把锁拿了出来,但突然又想再学习一会,因为该学生离锁最近,于是该学生又把锁抢走,去上自习,其他学生又只能等待,但该学生没上几分钟又坐不住出去了,然后又想再学习一会回来,就这样循环往复,导致其他学生无法竞争到锁,为了让其他学生可以竞争到锁,就规定让该学生把锁拿出来后去后面排队。

上面例子中的教室就是临界资源,学生就是线程

条件变量

条件变量用来描述某种临界资源是否就绪的一种数据化描述

条件变量是Linux中提供的一种同步的机制,用来表示某种条件是否成立

struct pthread_cond_t
{
 
	int flag;
	task_struct* queue;
}

例子 : 一个学生拿着锁进了教室,其他学生来了只能等待锁,这时可以设置一个条件变量(可以看作一个结构体,flag == 0表示无钥匙,flag == 1表示有钥匙,task_struct* queue指向等待队列的队头线程),用来描述锁是否被拿出来了,其他学生就可以在条件变量下等待,flag == 1时就可以唤醒排在队列头的线程,因此条件变量就是用来描述某种临界资源状态是否就绪

条件变量需要配合mutex互斥锁一起使用

int pthread_cond_wait(pthread_cond_t *restrict cond,pthread_mutex_t *restrict mutex); 参数:
cond:要在这个条件变量上等待 
mutex:释放互斥锁
调用该接口默认条件不满足,会开始阻塞
int pthread_cond_signal(pthread_cond_t *cond);
功能 : 唤醒在条件变量上等待的第一个线程
int pthread_cond_broadcast(pthread_cond_t *cond);
功能 : 唤醒在条件变量上等待的所有线程
1 #include<iostream>
  2 #include<cstdio>
  3 #include<pthread.h>
  4 using namespace std;
  5 pthread_mutex_t lock;
  6 pthread_cond_t cond;
  7 void* Run(void* arg)
  8 {
 
  9     pthread_detach(pthread_self());
 10     cout<<(char*)arg<<" : "<<pthread_self()<<" run...."<<endl;
 11     while(1)
 12     {
 
 13         pthread_cond_wait(&cond,&lock);
 14         cout<<"thread : "<<pthread_self()<<" activity"<<endl;
 15     }
 16 }
 17 int main()
 18 {
 
 19     pthread_mutex_init(&lock,nullptr);
 20     pthread_cond_init(&cond,nullptr);
 21 
 22     pthread_t t1,t2,t3;
 23     pthread_create(&t1,nullptr,Run,(void*)"thread 1");
 24     pthread_create(&t2,nullptr,Run,(void*)"thread 2");
 25     pthread_create(&t3,nullptr,Run,(void*)"thread 3");
 26 
 27     while(1)
 28     {
 
 29         getchar();
 30         pthread_cond_signal(&cond);
 			// pthread_cond_broadcast(&cond); 唤醒所有等待线程
 31     }
 32     pthread_mutex_destroy(&lock);
 33     pthread_cond_destroy(&cond);
 34     return 0;
 35 }

生产者消费者模型 : 是经典的多线程同步与互斥的一个场景

拿去超市买东西为例,超市本身不生产商品,会从生产者拿对应的商品,超市里的柜台中放着商品

假如某一天超市的柜台里没有商品了,消费者去超市里买商品,发现没有商品就回去了,消费者只能轮询的去超市查看有没有商品

假如某一天超市的柜台已经满了,生产者只能轮询的去查看超市是否缺货了

消费者,生产者每次轮询的去询问超市是否有货/缺货,太浪费时间了,所以消费者和生产者都加了超市工作人员的微信,等超市有货/缺货给消费者/生产者发送消息来告知他们,超市有货了给消费者发微信让消费者来消费,超市缺货了给生产者发微信让生产者来供货

超市在供货时是不能消费的,在消费时是不能供货的,所以需要使用mutex互斥锁来实现,消费者申请锁来超市消费,消费期间生产者不能进来,消费者消费完释放锁,生产者申请到锁来供货,供货期间消费者不能来消费,供货完生产者释放锁

三种关系 : 消费者和消费者,生产者和生产者,生产者和消费者

消费者和消费者之间是互斥关系(竞争关系)

生产者和生产者之间是互斥关系(竞争关系)

生产者和消费者之间是同步(多线程协同)和互斥关系(竞争关系)

两种角色 : 生产者和消费者(通常由特定的线程和进程来承担)

一个交易场所 : 通常是内存中的一段缓冲区

为什么存在生产者和消费者模型?

(1). 在函数调用中,main 函数 调用了 fun(int a,int b) 函数,main 函数必须等 fun 函数跑完才能回到 main 函数中继续执行,函数调用的本质就是把数据给一个函数,然后通过该函数拿到数据处理后的结果。所以函数调用是一种紧耦合

生产者把数据交给缓冲区,消费者从缓冲区中拿数据进行计算,对于生产者来讲,生产者把数据交给缓冲区,生产者就可以往后执行了,并不会因为计算没有出现结果而阻塞,双方就可以并发或并行的执行了,所以生产者和消费者模型实现了解耦

(2). 支持并发

(3). 如果生产数据过程特别慢,消费数据过程特别快,如果再把它们紧耦合起来,最终系统的效率会被拖慢,所以我们可以让生产者多一些,消费者少一些,即支持忙闲不均

为什么 pthread_cond_wait 中第二个参数要传入 mutex 互斥锁?

等待的时候往往是在临界区等待的,此时线程申请了锁,如果不把锁释放,会导致死锁问题,因此传入第二个参数mutex互斥锁,在进行等待时,会自动释放互斥锁,如果当前等待线程被唤醒,会自动获得互斥锁

BlockQueue.hpp

1 #pragma once
  2 #include<iostream>
  3 #include<queue>
  4 #include<pthread.h>
  5 #include<cstdlib>
  6 #include<ctime>
  7 #include<unistd.h>
  8 #define NUM 5
  9 using namespace std;
 10 template<class T>
 11 class BlockQueue
 12 {
 
 13 private:
 14     bool IsFull()
 15     {
 
 16         return _q.size() == _cap;
 17     }
 18     bool IsEmpty()
 19     {
 
 20         return _q.empty();
 21     }
 22 public:
 23     BlockQueue(int cap = NUM)
 24         :_cap(cap)
 25     {
 
 26         pthread_mutex_init(&lock,nullptr);
 27         pthread_cond_init(&full,nullptr);
 28         pthread_cond_init(&empty,nullptr);
 29     }
 30     ~BlockQueue()
 31     {
 
 32         pthread_mutex_destroy(&lock);
 33         pthread_cond_destroy(&full);
 34         pthread_cond_destroy(&empty);
 35     }
 36     void Push(const T& val)
 37     {
 
 38         pthread_mutex_lock(&lock);
 39         while(IsFull())
 40         {
 
 41             pthread_cond_wait(&full,&lock);
 42         }
 43         _q.push(val);
 44         pthread_mutex_unlock(&lock);
 45         pthread_cond_signal(&empty);
 46     }
 47     void Pop(T& val)
 48     {
 
 49         pthread_mutex_lock(&lock);
 50         while(IsEmpty())
 51         {
 
 52             pthread_cond_wait(&empty,&lock);
 53         }
 54         val = _q.front();
 55         _q.pop();
 56         pthread_mutex_unlock(&lock);
 57         pthread_cond_signal(&full);
 58     }
 59 private:
 60     queue<T> _q;
 61     int _cap;
 62     pthread_mutex_t lock;
 63     pthread_cond_t full;
 64     pthread_cond_t empty;
 65 };

main.cc

1 #include"BlockQueue.hpp"
  2 void* Consumer(void* arg)
  3 {
 
  4     auto bq = (BlockQueue<int>*)arg;
  5     while(1)
  6     {
 
  7         sleep(1); // 消费者消费慢
  		//  消费者消费快
  8         int data = 0;
  9         bq->Pop(data);
 10         cout<<"Consumer : "<<data<<endl;
 11     }
 12 }
 13 void* Producter(void* arg)
 14 {
 
 15     auto bq = (BlockQueue<int>*)arg;
 16     while(1)
 17     {
 
 18        生产者生产快
 		 // sleep(1);  生产者生产慢
 19         int data = rand() % 100 + 1;
 20         bq->Push(data);
 21         cout<<"Producter : "<<data<<endl;
 22     }
 23 }
 24 int main()
 25 {
 
 26     srand((unsigned long)time(nullptr)); // 产生随机数
 27     BlockQueue<int>* bq = new BlockQueue<int>;
 28     pthread_t c,p;
 29     pthread_create(&c,nullptr,Consumer,bq);
 30     pthread_create(&p,nullptr,Producter,bq);
 31 	pthread_join(c,nullptr);
 32     pthread_join(p,nullptr);
 33     return 0;
 34 }

BlockQueue.hpp

1 #pragma once
  2 #include<iostream>
  3 #include<queue>
  4 #include<pthread.h>
  5 #include<cstdlib>
  6 #include<ctime>
  7 #include<unistd.h>
  8 #define NUM 32
  9 using namespace std;
 10 template<class T>
 11 class BlockQueue
 12 {
 
 13 private:
 14     bool IsFull()
 15     {
 
 16         return _q.size() == _cap;
 17     }
 18     bool IsEmpty()
 19     {
 
 20         return _q.empty();
 21     }
 22 public:
 23     BlockQueue(int cap = NUM)
 24         :_cap(cap)
 25     {
 
 26         pthread_mutex_init(&lock,nullptr);
 27         pthread_cond_init(&full,nullptr);
 28         pthread_cond_init(&empty,nullptr);
 29     }
 30     ~BlockQueue()
 31     {
 
 32         pthread_mutex_destroy(&lock);
 33         pthread_cond_destroy(&full);
 34         pthread_cond_destroy(&empty);
 35     }
 36     void Push(const T& val)
 37     {
 
 38         pthread_mutex_lock(&lock);
 39         while(IsFull())
 40         {
 
 41             pthread_cond_wait(&full,&lock);
 42         }
 43         _q.push(val);
 			if(_q.size() >= _cap / 2)
 			{
 
 				 cout<<"数据很多了,消费者快来消费吧"<<endl;
 				 pthread_cond_signal(&empty);
 			}
 44         pthread_mutex_unlock(&lock);
 46     }
 47     void Pop(T& val)
 48     {
 
 49         pthread_mutex_lock(&lock);
 50         while(IsEmpty())
 51         {
 
 52             pthread_cond_wait(&empty,&lock);
 53         }
 54         val = _q.front();
 55         _q.pop();
 			if(_q.size() <= _cap / 2)
 			{
 
 				cout<<"空间很多了,快来生产吧"<<endl;
 				pthread_cond_signal(&full);
 			}
 56         pthread_mutex_unlock(&lock);
 58     }
 59 private:
 60     queue<T> _q;
 61     int _cap;
 62     pthread_mutex_t lock;
 63     pthread_cond_t full;
 64     pthread_cond_t empty;
 65 };

main.cc

1 #include"BlockQueue.hpp"
  2 void* Consumer(void* arg)
  3 {
 
  4     auto bq = (BlockQueue<int>*)arg;
  5     while(1)
  6     {
 
  7         sleep(1);
  8         int data = 0;
  9         bq->Pop(data);
 10         cout<<"Consumer : "<<data<<endl;
 11     }
 12 }
 13 void* Producter(void* arg)
 14 {
 
 15     auto bq = (BlockQueue<int>*)arg;
 16     while(1)
 17     {
 
 19         int data = rand() % 100 + 1;
 20         bq->Push(data);
 21         cout<<"Producter : "<<data<<endl;
 22     }
 23 }
 24 int main()
 25 {
 
 26     srand((unsigned long)time(nullptr)); // 产生随机数
 27     BlockQueue<int>* bq = new BlockQueue<int>;
 28     pthread_t c,p;
 29     pthread_create(&c,nullptr,Consumer,bq);
 30     pthread_create(&p,nullptr,Producter,bq);
 31 	pthread_join(c,nullptr);
 32     pthread_join(p,nullptr);
 33     return 0;
 34 }

为什么使用 while(IsFull()) 而不是 if(IsFull()) ?

pthread_cond_wait 是让当前执行流进行等待的函数,该函数有可能调用失败,或者被伪唤醒

对于生产者如果队列满了,调用pthread_cond_wait函数使生产者进行等待,但函数调用失败并没有成功让生产者等待,当前执行流还会继续向下执行_q.push(val)导致出错

对于消费者如果队列空了,调用pthread_cond_wait函数使消费者进行等待,但函数调用失败并没有成功让消费者等待,当前执行流还会继续向下执行_q.front(),_q.pop() 导致出错

单生产者多消费者情况下,没有数据时多消费者处于阻塞状态,生产者生产一个数据后如果调用 pthread_cond_broadcast(&empty) 唤醒所有消费者去消费,就会出现问题

所以使用while循环让线程被唤醒时并不着急向后执行,而是再重新检测是否还满足条件

生产者和消费者协同完成任务

Task.hpp

1 #pragma once
  2 #include<iostream>
  3 using namespace std;
  4 class Task
  5 {
 
  6 public:
  7     Task(int x,int y,char op)
  8         :_x(x)
  9         ,_y(y)
 10         ,_op(op)
 11     {
 }
 12     Task()
 13     {
 }
 14     void Run()
 15     {
 
 16         int result = 0;
 17         switch(_op)
 18         {
 
 19             case '+':
 20                 result = _x + _y;
 21                 break;
 22             case '-':
 23                 result = _x - _y;
 24                 break;
 25             case '*':
 26                 result = _x * _y;
 27                 break;
 28             case '/':
 29                 if(_y == 0)
 30                 {
 
 31                     cout<<"Warning : div zero"<<endl;
 32                     result = -1;
 33                 }
 34                 else
 35                 {
 
 36                     result = _x / _y;
 37                 }
 38                 break;
 39             default:
 40                 break;
 41         }
 42         cout<<_x<<_op<<_y<<"="<<result<<endl;
 43     }
 44     ~Task()
 45     {
 }
 46 
 47 private:
 48     int _x;
 49     int _y;
 50     char _op;
 51 };

POSIX信号量

什么是信号量(信号灯)?

信号量本质上是一个计数器,描述临界资源中资源数目的计数器,相比于互斥锁可以更细粒度的管理临界资源

申请到信号量的本质 : 并不是已经开始使用临界资源中申请的某个区域,而是拥有了申请的某个区域的权限(好比在网上买电影票预定座位,预定座位以后并不一定要坐到座位上,而是拥有了这个座位的权限)

申请信号量(P操作)的本质 : 让计数器- -

释放信号量(V操作)的本质 : 让计数器++

每个线程或执行流在进入临界资源的时候,都必须先申请信号量,操作特定的临界资源,最后释放信号量

每个线程在进入临界资源时都要申请信号量,所以信号量也是临界资源,信号量的P,V操作必须是原子的

进行PV操作时,一定有一种情况,P操作有可能申请不到,当前线程会在信号量的等待队列中阻塞等待

多个线程去申请信号量时,(信号量为0的话将当前线程的task_struct链入到等待队列中),申请到信号量的线程拿到锁,计数器- -,当别的线程进行了V操作,信号量就可以在等待队列中唤醒一个线程

struct
{
 
	mutex_t lock;
	int count;
	task_struct* queue;
}

二元信号量实现互斥

1 #include<iostream>
  2 #include<unistd.h>
  3 #include<cstdio>
  4 #include<pthread.h>
  5 #include<semaphore.h>
  6 using namespace std;
  7 class Sem
  8 {
 
  9 public:
 10     Sem(int num)
 11     {
 
 12         sem_init(&_sem,0,num);
 13     }
 14     void P()
 15     {
 
 16         sem_wait(&_sem);
 17     }
 18     void V()
 19     {
 
 20         sem_post(&_sem);
 21     }
 22     ~Sem()
 23     {
 
 24         sem_destroy(&_sem);
 25     }
 26 private:
 27     sem_t _sem;
 28 };
 29 Sem sem(1);
 30 int tickets = 10000;
 31 void* Gettickets(void* arg)
 32 {
 
 33     while(1)
 34     {
 
 35         sem.P();
 36         if(tickets > 0)
 37         {
 
 38             usleep(10000);
 39             printf("%s got a ticket : %d\n",(char*)arg,tickets--);
 40             sem.V();
 41         }
 42         else
 43         {
 
 44             sem.V();
 45             break;
 46         }
 47     }
 48 }
 49 int main()
 50 {
 
 51    pthread_t tid1,tid2,tid3;
 52    pthread_create(&tid1,nullptr,Gettickets,(void*)"thread 1");
 53    pthread_create(&tid2,nullptr,Gettickets,(void*)"thread 2");
 54    pthread_create(&tid3,nullptr,Gettickets,(void*)"thread 3");
 55 
 56    pthread_join(tid1,nullptr);
 57    pthread_join(tid2,nullptr);
 58    pthread_join(tid3,nullptr);
 59 
 60    return 0;
 61 }
%s/ / /g

基于环形队列的生产消费模型

(1). 生产者和消费者同时执行,一定是生产者先运行,因为最开始没有数据资源让消费者消费,但是有空间资源让生产者生产

(2). 不会存在数据不一致的问题,因为只有生产者和消费者指向同一位置,才会有临界资源竞争的问题,而生产者和消费者指向同一位置只有两种情况,1. 环形队列为空的时候,一定是生产者先生产,消费者再消费 2. 环形队列满的时候,一定是消费者先消费,生产者再生产

RingQueue.hpp

#pragma once
  2 
  3 #include<iostream>
  4 #include<pthread.h>
  5 #include<queue>
  6 #include<cstdlib>
  7 #include<unistd.h>
  8 #include<vector>
  9 
 10 template<class T>
 11 class RingQueue{
 
 12 private:
 13     std::vector<T> q;
 14     int cap;
 15 
 16     sem_t blank_sem;
 17     sem_t data_sem;
 18 
 19     int p_pos;
 20     int c_pos;                                                                                                             
 21          
 22     void P(sem_t& s){
 
 23         sem_wait(&s);
 24     }
 25     void V(sem_t& s){
 
   sem_post(&s);
 27     }
 28 public:
 29     RingQueue(int _cap){
 
 30         
 31         cap = _cap;
 32         q.resize(cap);
 33         sem_init(&blank_sem,0,cap);
 34         sem_init(&data_sem,0,0);
 35         p_pos = 0;
 36         c_pos = 0;
 37     }
 38     void Push(const T& in){
 
 39         P(blank_sem);
 40         q[p_pos] = in;
 41         V(data_sem);
 42 
 43         p_pos++;
 44         p_pos %= cap;
 45     }
 		void Pop(T& out){
 
 48 
 49        P(data_sem); 
 50        out = q[c_pos];
 51        V(blank_sem);
 52 
 53        c_pos++;
 54        c_pos %= cap;
 55     }
 56 };

main.cc

#include"RingQueue.hpp"                                                                                                    
  2 
  3 void* Consumer(void* arg)
  4 {
 
  5     auto bq = (RingQueue<int>*)arg;
  6     while(1)
  7     {
 
  8         sleep(3);
  9         int data;
 10         bq->Pop(data);
 11         std::cout<<"Consumer : "<<data<<std::endl;
 12     }
 13 }
 14 
 15 void* Producter(void* arg)
 16 {
 
 17     auto bq = (RingQueue<int>*)arg;
 18     while(1)
 19     {
 
 20         int data = rand() % 100 + 1;
 21         bq->Push(data);
 22         std::cout<<"Producter : "<<data<<std::endl;
 23     }
 24 }
	int main()
 27 {
    
 28     srand((unsigned long)time(nullptr)); // 产生随机数
 29     RingQueue<int>* bq = new RingQueue<int>;
 30     pthread_t c,p;
 31     pthread_create(&c,nullptr,Consumer,bq);
 32     pthread_create(&p,nullptr,Producter,bq);
 33     pthread_join(c,nullptr);
 34     pthread_join(p,nullptr);
 35 
 36     return 0;
 37 }

九. 线程池

ThreadPool.hpp

#pragma once                                                                                                               
  2 
  3 #include<iostream>
  4 #include<pthread.h>
  5 #include<queue>
  6 #include<cstdlib>
  7 #include<unistd.h>
  8 #include<vector>
  9 #include<semaphore.h>
 10 #include"Task.hpp"
 11 
 12 #define NUM 5
 13 
 14 template<class T>
 15 class ThreadPool{
 
 16 private:
 17     int num;
 18     std::queue<T> q;
 19     pthread_mutex_t lock;
 20     pthread_cond_t cond;
 21 public:
 22     ThreadPool(int _num = NUM):num(_num)
 23     {
 
 24         pthread_mutex_init(&lock,nullptr);
 25         pthread_cond_init(&cond,nullptr);
		}
 27 
 28     void Lock(){
 
 29         pthread_mutex_lock(&lock);
 30     }
 31 
 32     void UnLock(){
 
 33         pthread_mutex_unlock(&lock);
 34     }
 35 
 36     void Wait(){
 
 37         pthread_cond_wait(&cond,&lock);
 38     }
 39 
 40     void WakeUp(){
 
 41         pthread_cond_signal(&cond);
 42     }
 43 
 44     bool Empty(){
 
 45         return q.empty();
 46     }
 47 
 48     static void* Routine(void* arg){
 
 49 
 50         pthread_detach(pthread_self());  
 			ThreadPool<T>* self = (ThreadPool<T>*)arg;
 52         while(1){
 
 53             self->Lock();
 54             while(self->Empty()){
 
 55                 self->Wait();
 56             }
 57             Task t;
 58             self->Pop(t);
 59             self->UnLock();
 60 
 61             t.Run();
 62         }
 63     }
 64 
 65     void InitThreadPool(){
 
 66         pthread_t tid;
 67         for(int i = 0;i < num;i++){
 
 68             pthread_create(&tid,nullptr,Routine,this);          
 69         }
 70     }
 71 
 72 
 73     void Push(const T& in){
 
 74         Lock();
 75         q.push(in);               
 			UnLock();
 77         WakeUp();
 78     }
 79 
 80 
 81     void Pop(T& out){
 
 82         out = q.front();
 83         q.pop();
 84     }
 85 
 86     ~ThreadPool(){
 
 87         pthread_mutex_destroy(&lock);
 88         pthread_cond_destroy(&cond);
 89     }
 90 
 91 };

Task.hpp

#pragma once                                                                                                               
  2 
  3 class Task{
 
  4 private:
  5     int x;
  6     int y;
  7     char op;
  8 public:
  9     Task(){
 
 10 
 11     }
 12 
 13     Task(int _x,int _y,char _op)
 14         :x(_x)
 15         ,y(_y)
 16         ,op(_op)
 17     {
 }
 18 
 19     void Run(){
 
 20 
 21         int result = 0;
 22         switch(op){
 
 23             case '+' :
 24             result = x + y;
 25             break;
				case '-' :
 27             result = x - y;
 28             break;
 29             case '*' :
 30             result = x * y;
 31             break;
 32             case '/' :
 33             {
 
 34                 if(!y){
 
 35                     std::cout<<"除 0"<<std::endl;
 36                     return;
 37                 }
 38                 result = x / y;
 39             }
 40             default:
 41             break;
 42         }
 43         std::cout<<x<<op<<y<<" = "<<result<<std::endl;
 44     }
 45 };

main.cc

#include"ThreadPool.hpp"
  2 
  3 int main()
  4 {
 
  5     srand((unsigned long)time(nullptr)); // 产生随机数
  6     ThreadPool<Task>* tp = new ThreadPool<Task>;
  7     tp->InitThreadPool();                                                                                                  
  8     const char* arr = "+-*/";
  9     while(1){
 
 10         int x = rand() % 100 + 1;
 11         int y = rand() % 100 + 1;
 12         char op = arr[rand() % 4];
 13 
 14         Task t(x,y,op);
 15         tp->Push(t);
 16     }
 17 
 18     return 0;
 19 }

挂起等待锁 : 申请资源失败,线程会被阻塞挂起

自旋锁 : 申请资源失败,线程会一直循环检测资源是否准备就绪

读写锁 :

自旋锁

#include <pthread.h>
int pthread_spin_init(pthread_spinlock_t *lock,int pshared);
int pthread_spin_destroy(pthread_spinlock_t *lock);
int pthread_spin_lock(pthread_spinlock_t *lock);
int pthread_spin_trylock(pthread_spinlock_t *lock);
// 自旋1次,如果申请锁不成功,返回让用户决定该怎么做
int pthread_spin_unlock(pthread_spinlock_t *lock);

读者写者问题(如同班级策划黑板报)

3种关系 :

读者和读者 : 没有关系(读者只是进行数据拷贝(只是对黑板报的内容进行读取),因此没有关系)

读者和写者 : 互斥(读黑板报的人不能在写黑板报的人还没写完之前就去读,因为会导致读取的内容错误)和同步关系(写者写完黑板报,需要让读者读)

写者和写者 : 互斥关系(两人不能同时在黑板的同一区域内进行写入)

应用场景 : 数据写入之后,剩下的操作就是读取(如写黑板报/写日记后让其他人来读),写入数据少,读取数据多

如注册(写入数据)和登录(读取数据)网站

读者和写者问题是由角色强决定的,读者按照读的方式进行加锁,写者按照写的方式进行加锁

多线程情况下,读写同时到来,如果还有人在读,接下来读者不要进入临界区读,等写者写入,然后读者再读(写者优先),反之就叫做读者优先

Linux C++多线程编程 1.介绍   使用多线程的理由之一是和进程相比,它是一种非常”节俭”的多任务操作方式。我们知道,在Linux系统下,启动一个新的进程必须分配给它独立的地址空间,建立众多的数据表来维护它的代码段、堆栈段和数据段,这是一种”昂贵”的多任务工作方式。而运行一个进程中的多个线程,它们彼此之间使用相同的地址空间,共享大部分数据,启动一个线程所花费的空间远远小于启动一个进程,而且,线程间彼此切换所需的时间也... 阅读详情

相关推荐

Linux C++ 多线程实战一——多线程排序

    由于最近在学习C++从底层(指针,对象模型,内存管理)再到网络socket编程,多线程编程,数据库编程等方面知识,需要从Java慢慢的迁移过来。这是以前学习Java的学习路线,所以就把原来Java的做的项目全部用C++重新实现一遍。1. 多线程基础    这个可以看我的博客,里面都有详细的介绍以及如何使用linux C++多线程编程,参考如下:    Linux C++ 多线程编程基础(汇...

PurpleDream的博客 3403

c语言void* arg,void * arg什么意思

许多初学者对C/C++语言中的void及void指针类型不甚理解,因此在使用上出现了一些错误。本文将对void关键字的深刻含义进行解说,并详述void及void指针类型的使用方法与技巧。2.void的含义void的字面意思是“无类型”,void *则为“无类型指针”,void *可以指向任何类型的数据。void几乎只有“注释”和限制程序的作用,因为从来没有人会定义一个void变量,让我们试着来定义...

weixin_42099302的博客 9000

Linux——多线程编程

•。

weixin_51526796的博客 1045

变量 void *arg

void Prin_1(void *arg) //arg 就是一个void 类型变量,* 没用。 用int强制转化 { int a=(int) arg; } void Prin_2(void *arg) //arg 是一个void的指针变量,指向一个地址(int *)强制转化为int类型指针 { int a=*(int*) arg; } in

haicai1989的专栏 5111

基于CatBoost回归模型的完整预测分析:从建模到SHAP可解释性分析

本文介绍了使用CatBoost回归模型进行完整预测分析的流程。首先导入必要的Python库并加载数据,进行数据预处理包括训练测试集划分和归一化处理。然后通过网格搜索优化CatBoost超参数,使用最优参数训练模型并评估预测性能。结果显示模型具有较高的决定系数(R²=0.9944)和较低的误差指标(RMSE=0.0696)。接着进行残差分析和正态性检验,发现残差基本服从正态分布。最后通过SHAP分析实现模型可解释性,识别关键特征影响。该方法为梯度提升树在回归问题中的应用提供了完整解决方案。

fx666_的博客 748

STC15W204S最小系统开发指南:从串口通讯到自动热加载全流程

本文详细介绍了STC15W204S最小系统的完整开发流程。从芯片资源解析、最小系统搭建、串口通讯驱动编写(使用Timer2生成波特率),到实现基于魔术值触发的自动热加载功能,并最终集成Keil与STC-ISP软件,构建高效的自动化开发工作流,显著提升嵌入式调试效率。

a1b2c的博客 397

线程的故事——附2:线程建立函数参数void *arg深入分析

线程建立函数参数void *arg深入分析 如果const pthread_attr_t *attr相当于老板招募的职工所具有的业务素质的话,那void *arg就相当于老板能提供给职工的工作条件了。 function:int pthread_create(pthread_t ...

Sleeping_sunshine的博客 5257

Unity类银河恶魔城学习记录1-10 PlayerWallJump源代码 P37

Alex教程每一P的教程原代码加上我自己的理解初步理解写的注释,可供学习Alex教程的人参考

Homura_的博客 1381

void * 返回类型 与 void *arg 参数的区别

void *void *作为函数的返回类型,表示该函数可以返回任何类型的指针。void *是一种特殊的指针类型,称为“无类型指针”或“泛型指针”,因为它可以指向任何类型的数据。函数通过返回void *类型的指针,提供了高度的灵活性,允许调用者将返回的指针转换为任何具体的数据类型指针。void *arg:在函数参数中,void *arg表示该函数接受一个void*类型的参数。这同样表明,传递给的参数可以是任何类型的数据的指针。该参数在传递给函数之前不需要指定具体的数据类型,使得。

m0_67545273的博客 958

从零搭建Simulink-Adams联合仿真平台:实现电机转速的精准闭环控制

本文详细介绍了从零搭建Simulink-Adams联合仿真平台的完整流程,旨在实现电机转速的精准闭环控制。通过将Simulink的控制算法与Adams的物理模型相结合,构建了一个包含真实机械效应的数字孪生系统。文章涵盖了Adams物理模型构建、接口定义、Simulink控制闭环搭建、PID参数调试以及常见避坑指南,为机电系统仿真提供了实用的工程实践指导。

weixin_29189373的博客 154

CVPR2023新作HAT实战:5分钟搞定图像超分辨率重建(附代码)

本文介绍了CVPR2023新作HAT模型在图像超分辨率重建中的实战应用。HAT通过创新的混合注意力机制,显著提升了图像重建质量,能激活更多有效像素并减少伪影。文章提供了从环境配置到模型部署的完整指南,帮助开发者在5分钟内快速实现图像超分辨率重建,并附有代码示例和性能优化技巧。

weixin_29062613的博客 239

Linux多线程编程

Linux多线程编程一、线程理论基础二、多线程程序设计三、线程==同步==(按顺序) 一、线程理论基础 有了进程,为何还要引入线程呢?使用多线程有哪些好处? 1、和进程相比,线程是一种非常节俭的多任务操作方式,启动一个新的进程必须分配给它独立的地址空间,建立众多的数据表维护它的代码段、堆栈段、数据段,这是一种昂贵的多任务工作方式 运行于一个进程中的多线程,它们之间使用相同的地址空间,而且线程间彼此切换所需的时间也远远小于进程间切换所需要的时间 2、线程间方便的通讯机制,对不同进程来说,它们具有独立的数据空间

qq_46186025的博客 4809

雷电模拟器+Python 3.11:手把手教你用Frida-dexdump给安卓APK脱壳(附GDA查壳)

本文详细介绍了如何使用雷电模拟器和Python 3.11配合Frida-dexdump工具进行安卓APK脱壳的全流程。从环境配置、工具安装到脱壳操作和问题排查,提供了包含30+关键截图的保姆级教程,适合零基础用户快速上手。重点讲解了Frida工具链的使用技巧和GDA查壳方法,帮助读者掌握移动应用安全分析的基础技能。

weixin_42568801的博客 329

【Linux系统】Linux多线程详解

由上图可以很好地理解线程为什么是CPU调度的基本单位,在CPU看来,它只关心一个独立的执行流,无论进程内部是一个还是多个执行流,CPU都是以task_struct为单位来调度的。如果计算密集型线程的数量比可用的处理器多,那么可能会有较大的性能损失,这里的性能损失指的是增加了额外的同步和调度开销,而可用的资源不变。在操作系统的的视角下,Linux下没有真正意义的线程,而是用进程模拟的线程(LWP,轻量级进程),所以Linux不会提供直接创建线程的系统调用,最多提供创建轻量级进程的接口。个字节,也就是1MB。

fufufu_的博客 6773

ECU-TEST新手入门:从软件申请到第一个测试包创建的完整保姆级流程

本文详细介绍了ECU-TEST软件从申请试用、安装配置到创建第一个测试包的完整流程。针对新手用户,提供分步指导,包括界面认知、测试组件添加、变量定义及执行结果分析,帮助快速掌握汽车电子测试工具的基本操作。特别说明试用授权的两种获取方式和安装注意事项。

weixin_30606461的博客 481

Power Switch与Tap Cell关系

tap cell可以选用一般类型的tap cell,无须secondary pg pin,因为此时switch cell的阱电位接到输入power net上了,switch cell可以正常上电,也可以给core内正常供电,tap cell的阱电位接switch cell输出的power,需要注意的是此时switch cell与core内其他cell的阱电位是不同的,所以为了避免drc问题,需要在switch上盖hard blockage或者keepout margin。2)自带阱偏置的switch。

m0_61544122的博客 2339

Linux下多线程

Linux下多线程

zgwnb666的博客 1086

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Linux 多线程

一、线程理论基础 1、定义 线程( thread )技术早在60年代就被提出,但真正应用多线程到操作系统中去,是在80年代中期,solaris是这方面的佼佼者.传统的Unix也支持线程的概念,但是在一个进程( process )中只允许有一个线程,这样多线程就意味着多进程.现在,多线程技术已经被许多操作系统所支持,包括Windows/NT、Linux( thread )。 2、优点 (1)(与进程相比) ①和进程相比,它是一种非常“节俭”的多任务操作方式。在Linux系统下,启动一个新的进程必须分

weixin_42849105的博客 2423

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

Linux多线程详解

在一个程序里的一个执行路线就叫做线程(thread)。更准确的定义是:线程是“一个进程内部的控制序列”。 - 每个进程至少都有一个执行线程。 线程在进程内部运行,本质是在进程地址空间内运行。在Linux系统中,在CPU眼中,看到的PCB都要比传统的进程更轻量化。透过进程虚拟地址空间,可以看到进程的大部分资源,将进程资源合理分配给每个执行流,就形成了线程执行流

m0_72532428的博客 1144

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

【Linux】Linux下多线程

Linux下线程;线程的概念;进程地址空间和页表的理解;Linux线程控制,线程等待;封装C++版本线程库

weixin_63249832的博客 1107

Linux多线程编程小结

 Linux多线程编程小结       前一段时间因为开题的事情一直耽搁了我搞Linux的进度,搞的我之前学的东西都遗忘了,很烦躁的说,现在抽个时间把之前所学的做个小节。文章内容主要总结于《Linux程序设计第3版》。1.Linux进程与线程       Linux进程创建一个新线程时,线程将拥有自己的栈(因为线程有自己的局部变量),但与它的创建者共享全局变量、文件描述符、信号句柄

愤怒的小狐狸----博客专栏 6万+
上一篇: 两万字带你了解Java多线程(详细大总结)
下一篇: 在Windows环境与Linux环境下搭建Zookeeper单机环境与集群环境
java_lujj
博客等级 码龄4年 18粉丝 152原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值