多线程

• 多线程基本概念
• 线程控制
• • 创建
  • 终止
  • 等待
  • 分离
• 线程安全
• • 基本概念
  • 实现
  • 互斥
  • • 互斥锁
    • 死锁
  • 同步
• 线程应用
• • 生产者与消费者模型
  • 线程池
  • 单例模式

多线程基本概念

线程是进程中一个执行流程，是 CPU 进行执行调度的基本单元；
进程是系统进行资源分配的基本单元。

Linux 下一个进程中是可以存在多个 pcb 的，一个 pcb 就是一个执行流程。

1、一个进程中有多个 pcb 与多个进程有多个 pcb 再多执行流程中使用有什么区别？

例如零件加工厂加工零件，若有多个零件需要加工
多进程：
相当于多开几个厂子，多个厂子可以同时进行零件加工；
因此资源消耗大，但是更稳定 健壮性强

多线程：
相当于在一个厂子里边多开几条生产线
资源消耗小，但是健壮性不如多进程

线程是 CPU 调用执行的基本单元，而 Linux 下 pcb 是程序运行过程的描述，因此 Linux 下线程是通过 pcb 来实现的

多进程：把多个任务分成多个程序，一个进程执行一个
多线程：把一个整体的程序分为几个不同模块，一个 pcb 负责调度一个模块

2、线程 vs 进程

进程是系统进行资源分配的基本单元（每运行一个程序，系统就要分配一次程序运行所需要的资源）

线程是 CPU 进行执行调度的基本单元，在Linux下是通过 pcb 来实现的，一个进程中可以有多个pcb，因此也被称为 轻量级进程 LWP

3、多进程 vs 多线程

多进程：程序更具健壮性、更稳定

多线程：
（1）线程间通信更加灵活（共享虚拟地址，包含进程间通信在内，全局变量、函数传参…）
（2）创建和销毁成本更低（线程之间很多资源都是共享的，创建一个线程不需要分配太多资源）
（3）同进程的线程间调度成本更低（CPU 上加载的快表信息，也表指针…都不需要替换）

对于程序的安全性要求大于性能和资源要求则使用多进程（例如 shell）；其余使用多线程

4、多个线程在同一个进程中同时运行为什么不会混乱？

（1）其实每个线程调度执行的就是一个函数；
vfork - 创建子进程，父子进程公用同一个虚拟地址空间，为了避免出现栈运行混乱，因此父进程阻塞直到子进程程序替换或退出

（2）多线程关于执行出现混乱的解决方案：把所有有可能出现混乱的地方给每个线程单独存一份：

线程间独有信息：标识符、栈、上下文数据、信号屏蔽字、errno…

线程间共享信息：虚拟地址空间、文件描述符表、信号处理方式、工作路径、用户ID 、组ID…

5、多任务处理中

多任务处理中使用多执行流完成：
可以更加充分地利用计算机资源， 提升任务处理效率

在多任务处理中使用多少执行流可以由压力测试得到最合适的数量，并不是执行流越多越好，因为执行流越多，cpu 切换调度就越频繁，若执行流太多，反而会造成切换调度消耗大量资源。

6、在任务处理中，程序分两种

（1）cpu 密集型程序：

一段程序几乎都是数据的运算

（2）IO 密集型程序：

一段程序中大部分都是 IO 操作（大部分时间都在进行 IO 操作以及等待，因此对 cpu 使用率并不高）

线程控制

线程中接口都是库函数实现的--------链接库文件 -lpthread

#include //头文件

创建

int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);

（1）thread：传入一个 pthread_t 类型变量的地址空间，用于接收线程 ID ---- 线程的操作句柄
（2）attr：线程属性----通常置NULL
（3）start_routine：函数指针，传入线程入口函数的地址，这个线程调度运行的就是这个函数
（4）arg：给 start_routine 线程入口函数传入的参数；
功能：创建一个线程，指定这个线程要运行的函数 start_routine ，并且给这个函数传入一个数据 arg
返回值：成功 0，失败返回非0

    1 #include                                                       2 #include3 #include4 5 void* thread_entry(void* arg)6 {7   //线程入口函数8   while(1){9     printf("i am nomal thread:%s\n",arg);10     sleep(1);11   }12   return NULL;13 }14 15 16 int main()17 {18   //线程的创建19    //int pthread_create(pthread_t *thread, const pthread_attr_t *attr,vo      id *(*start_routine) (void *), void *arg);20 21   pthread_t tid;     //用来保存线程 ID
W> 22   char* arg="leihoua!!";     //给线程入口函数传入的参数23 24   int ret=pthread_create(&tid,NULL,thread_entry,(void*)arg);25   if(ret!=0){26     printf("thread create error!\n");27     return -1;28   }29    30   //普通线程一旦创建成功，创建出来的这个线程调度的是传入的线程入口函数，      因此能够走下来的只有主线程31   //线程中不存在父子线程32   while(1){33     printf("i am main thread!!\n");34     sleep(1);35   }36   return 0;37 }                         

线程被创建出来之后，谁先运行不一定，看操作系统的调度

（1）创建一个线程其实就是让操作系统给我们提供一个执行流，至于这个线程做什么，取决于线程的入口函数（由程序员自己决定）

线程是一个执行流，调度一段函数运行

（进程：fork() 创建一个子进程之后，父子进程公用一段代码）

查看线程信息 ： ps -L 选项
查看的其实是轻量级进程信息

（2）一个程序运行起来，默认会创建一个线程（pcb），这个线程有自己的 pid
如果下边通过 pthread_create 创建了一个线程（pcb），这个线程也有自己的pid
真正使用 ps 查看进程信息的时候查看的是主线程pcb对应的信息

（3）pthread_create 接口创建第一个参数获取到的 tid 并不是轻量级进程的 pid（lwp）

tid 实际保存的是一个地址，这个地址指向了线程相对独立的空间

终止

线程终止：退出一个线程的运行

线程其实调用运行的是创建时所传入的入口函数，因此线程的入口函数运行完了，线程就退出了

1、在线程入口函数中 return

注意：main 函数中 return 退出的不仅仅是主线程，还有整个程序

2、在任意位置调用接口实现线程的退出
void pthread_exit(void *retval);
retval ：用于设置线程的退出返回值
谁调用谁退出

3、在任意位置调用接口用于取消指定线程的运行
int pthread_cancel(pthread_t thread);
一个线程若是被取消的，则返回值就不是一个正经的返回值

线程正常退出是有返回值设置的，但若是 pthread_cancel 取消线程的，则没有设置返回值。

等待

1、主线程退出，其实并不会影响其他线程的运行（不多见）；
所有线程退出了，则进程退出释放所有资源；
若进程要退出，则会先退出所有线程。
2、一个线程退出了，资源也并没有完全被释放（要保存返回值）

线程等待：

等待指定的线程退出，获取退出线程的返回值，回收退出线程的所有资源

int pthread_join(pthread_t thread, void **retval);
（1）thread：要等待退出的指定线程 tid
（2）retval：用于获取线程的退出返回值；因为线程退出返回值为 void，因此传入指针变量的地址，将变量的地址放在指针变量空间
返回值：成功返回 0，失败返回错误编号

线程等待：

#include
#include
#includevoid* thread_entry(void* arg)
{//线程入口函数int count=0;while(1){printf("i am nomal thread:%s\n",arg);count++;//pthread_exit(NULL);    //任意位置调用可以退出线程if(count==3)return "nihao ";         //返回值为字符串 类型sleep(1);}return NULL;
}int main()
{//线程的创建//int pthread_create(pthread_t *thread, const pthread_attr_t *attr,void *(*start_routine) (void *), void *arg);pthread_t tid;     //用来保存线程 IDchar* arg="leihoua!!";     //给线程入口函数传入的参数int ret=pthread_create(&tid,NULL,thread_entry,(void*)arg);if(ret!=0){printf("thread create error!\n");return -1;}//线程等待void* retval;   //用于接收退出返回值ret=pthread_join(tid,&retval);     //等待指定的线程 tid 退出，并获取退出返回值 retval  if(ret!=0){printf("pthread_join failed\n");return -1;}printf("exit----%s\n",retval);  //打印退出返回信息//pthread_cancel(tid);         //任意位置调用退出线程//普通线程一旦创建成功，创建出来的这个线程调度的是传入的线程入口函数，因此能够走下来的只有主线程//线程中不存在父子线程while(1){                      //打印线程IDprintf("i am main thread!!----%d\n",tid);sleep(1);}return 0;
}

运行结果：

线程之间传递数据一定要注意数据的生命周期
（可以是 malloc 动态申请的空间 \ static j静态数据 \ 字面常量 ）

若一个线程是被取消的，则获取的返回值是一个宏：PTHREAD_CANCELED ==== 》 (void*)(-1)

分离

在线程属性中，有一个属性叫做分离属性，默认值是 joinable 状态，表示线程退出后不会自动释放资源， 需要被其他线程等待。

但有时候我们并不关心一个线程的返回值，也不想等待它退出，则这个时候将这个分离属性设置为 detach 状态，表示线程退出后自动释放所有资源，不需要被释放（资源是自动释放的，因此也不能被等待）

int pthread_detach(pthread_t thread);
设置指定线程的分离属性为 detach
返回值：成功返回0 ，失败返回错误编号

=============================================================================================================================

线程安全

基本概念

不安全：在多线程程序中，若涉及到了对共享资源的操作，则有可能导致数据的二义性。

线程安全：对共享资源的操作不会导致数据二义性

实现

实现：如何实现多线程对共享资源的操作不会出问题？
同步：通过条件控制，让多执行对资源的获取更加合理
互斥：通过同一时间执行流对资源访问的唯一性，保证访问安全

互斥的实现：互斥锁（读写锁、自旋锁…）

同步的实现：条件变量、信号量

互斥锁实现互斥----实现对共享资源的唯一访问

本质也就是一个 0/1计数器，通过 0/1 标记资源的访问状态（0-不可访问，1-可访问）
在访问资源之前进行加锁操作（通过状态判断是否可以访问，不可访问则阻塞）；
在访问资源之后进行解锁操作（将资源状态置为可访问状态，唤醒其他阻塞的进程）；

多个线程想要实现互斥，就必须访问同一个锁-----------意味着锁是一个共享资源

互斥

互斥锁

互斥锁如何实现自身安全？----> 一步置换

互斥锁本身的计数器操作是原子操作

对变量内容的修改过程----------------将变量从内存中加载到（CPU）寄存器中，在寄存器中修改变量值，再将修改之后的值返回到内存中。

因此对于互斥锁来说，若某一个线程将互斥锁的数据（1-可访问）加载到cpu上进行处理，要修改成 0-不可访问，但是还没有将处理之后的数据返回内存之前，线程进行了切换，第二个进程也要进行加锁操作，要将互斥锁的值（1）加载到 cpu ，此时会形成矛盾。

因此 指令 exchange ：交换 cpu 指定寄存器与内存中的数据
互斥锁操作：
1）先将指定寄存器中值修改为 0
2）将寄存器与内存中数据互换
3）判断是否符号获取锁的条件/判断能否可以加锁

置换操作是一条指令完成的，不可被打断
置换之前，把寄存器的值置为 0，因此置换之后内存中互斥锁的值为 0，这样就保证，不管当前线程是否可以加锁，至少在之后的线程都不能进行加锁。

接口

pthread_mutex_t ：互斥锁变量类型

初始化互斥锁

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
（1）mutex：互斥锁变量地址
（2）attr：互斥锁变量属性-----NULL

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
这种初始化，不需要使用 destroy 进行释放

访问资源前进行加锁

int pthread_mutex_lock(pthread_mutex_t *mutex);
阻塞加锁； 加不上锁则一直等待

int pthread_mutex_trylock(pthread_mutex_t *mutex);
非阻塞加锁；加不上锁则立即报错返回

int pthread_mutex_unlock(pthread_mutex_t *mutex);
访问资源完毕之后进行解锁

释放销毁互斥锁

int pthread_mutex_destroy(pthread_mutex_t *mutex);

练习

1、多线程中共享资源访问若不加锁可能会出什么问题？

2、如何通过使用互斥锁来保护临界区（共享资源的访问过程）

练习代码：

#include
#includeint ticket=100;void* Scalper(void* arg)
{//入口函数while(1){if(ticket>0){printf("%p 抢到了 %d 号票\n",pthread_self(),ticket);ticket--;}else{printf("票没了~~！\n");break;}}return NULL;
}int main()
{pthread_t tid[4];   //创建四个线程int i=0;for(i=0;i<4;++i){int ret=pthread_create(&tid[i],NULL,Scalper,NULL);//四个线程调用入口函数的顺序是不一定的if(ret!=0){printf("create pthread error~!\n");return -1;}}for(i=0;i<4;++i){pthread_join(tid[i],NULL);      //等待指定的线程退出，退出返回值 NULL}return 0;
}

由于判断有没有票与抢票过程不是原子性的不是一次性完成的，中间有可能被打断，因此存在其他线程也可以抢-----------------------定义互斥锁

在定义线程之前定义锁， 并对其进行初始化操作。

#include
#include
#includeint ticket=100;void* Scalper(void* arg)
{pthread_mutex_t *mutex=(pthread_mutex_t*)arg;            //定义互斥锁//入口函数while(1){pthread_mutex_lock(mutex);   //进行加锁操作usleep(10);if(ticket>0){printf("%p 抢到了 %d 号票\n",pthread_self(),ticket);ticket--;//抢票结束进行解锁pthread_mutex_unlock(mutex);}else{printf("票没了~~！\n");pthread_mutex_unlock(mutex);   //加锁后在任意有可能退出线程的地方都需要解锁pthread_exit(NULL);    //线程退出}}usleep(1);return NULL;
}int main()
{pthread_t tid[4];   //创建四个线程pthread_mutex_t mutex;   //定义互斥锁pthread_mutex_init(&mutex,NULL);   //互斥锁的初始化操作int i=0;for(i=0;i<4;++i){int ret=pthread_create(&tid[i],NULL,Scalper,&mutex);  //将锁传给入口函数参数if(ret!=0){printf("create pthread error~!\n");return -1;}}for(i=0;i<4;++i){pthread_join(tid[i],NULL);      //等待指定的线程退出，退出返回值 NULL}//线程运行结束释放锁pthread_mutex_destroy(&mutex);return 0;
}

死锁

多个线程对锁资源的争抢使用不当导致程序流程卡死，无法继续向下推进的状态

（1）加锁之后没有释放就退出，导致其它线程获取不到锁资源卡死；
（2）多锁使用，加锁顺序不当，线程 1 加锁顺序为 AB，线程 2 加锁顺序为 BA

死锁产生的必要条件

（1）互斥条件：
同一时间一个锁只能被一个线程获取，多个线程无法同时加同一把锁；
（2）不可剥夺条件：
一个线程加的锁，只有自己可以释放，其他线程不能释放
（3）请求与保持条件：
线程加 A 锁后请求 B 锁，若请求不到 B 锁也不释放 A 锁
（4）环路等待条件：
线程 1 加锁 A 请求 B 锁，线程 2 加锁 B 请求 A 锁

预防死锁产生-------破坏死锁产生的必要条件

1、2 是互斥锁的要义所在，是无法进程破坏的；因此在写代码时应格外注意：
（1）多个线程间加锁顺序要保持一致：预防环路条件产生
（2）采用非阻塞加锁，若加不上锁，则把已经加锁成功的释放----破环请求与保护条件

避免死锁

（1）银行家算法--------风险控制

将系统运行状态分为：安全状态 、不安全状态
建立三张表：
资源剩余表：有没有这个资源可以分配

资源分配表：一旦请求的资源被分配了，是否会导致系统进入非安全状态（不能分配）

资源请求表：谁请求什么资源

（2）死锁检测算法

同步

通过条件控制让多线程对资源的获取更加合理

互斥只能保证安全，不一定能保证合理
同步能保持合理，不一定能保持安全

资源获取的合理：
有资源才能处理，没资源则阻塞—等有资源在唤醒处理

条件变量：
提供一个 pcb 等待队列以及阻塞和唤醒线程的接口
思想：若一个线程不满足获取资源的条件则通过阻塞接口阻塞线程
一个线程促使资源获取条件满足了，则通过唤醒接口唤醒线程
注意：条件变量本身并不知道什么时候该阻塞，什么时候唤醒，仅仅是提供了阻塞和唤醒的接口-------------具体由程序员来控制

线程应用

生产者与消费者模型

线程池

单例模式