【Linux】线程概念与线程控制

认识线程

线程是一个执行流（运行代码，处理数据）

​ 1.操作系统使用pcb来描述一个程序的运行-------pcb就是进程

​ 2.linux下通过pcb模拟实现线程，因此linux下的线程是一个轻量级进程
​ 3.这个轻量级进程因为公用大部分进程资源；相较于传统进程更加轻量化
进程是资源分配的基本单位----因为程序运行时资源分配给整个线程组（线程是cpu调度的基本单位-----因为linux pcb是线程）
​线程之间资源的独有与共享：
​ 独有：栈， 寄存器（自己的上下文数据[上文：处理过的数据；正文：正在处理的数据；下文：即将处理的数据]）， 信号屏蔽字（那个线程拿到时间片就会处理信号，若不想让该线程处理某信号，则在该线程信号屏蔽），errno(每个线程都有自己的errno,防止errno改正后，统一被修改)，线程ID，调度优先级

​ 共享：共享虚拟地址空间（共享代码段和数据段），文件描述符表（一个线程打开文件获取文件描述符可以直接传给另一个线程，另一个线程直接进行文件操作），当前工作路径，信号处理方式（信号处理方式一致，但是具体哪一个进程去处理是不一定的），用户id/组id

多进程与多线程的优缺点分析

多线程处理任务的优点：

• 线程间通信特别方便，除了进程间的通信方式，还可以通过全局变量/传参（共享资源）
• 创建和销毁一个线程的成本相比于进程要更低
• 线程间调度相较于进程要更低

多线程处理任务的缺点：

• 线程之间缺乏访问控制，有些系统调用/异常针对的是整个进程；稳定性相比于进程更低。场景：比如创建shell这种对主程序稳定安全性要求较高的程序，就需要用多进程，让子程序来背锅

线程控制

线程创建/线程终止/线程等待/线程分离
由于linux下操作系统并没有提供线程的控制系统调用接口，封装了一个线程控制接口库。使用库函数实现创建的线程我们称之为用户态线程，这个用户态线程在内核中使用一个轻量级进程实现调度。
POSIX线程库

• 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的
• 要使用这些库函数，要通过引入头文件<pthread.h>
• 链接这些线程函数库时，要使用编译器命令的"-lpthread"选项
  ​linux下的线程：用户态线程+轻量级进程

线程创建

//int pthread_create(pthread_t * thread,const pthread_attr_t *attr,
//void* (start_routine)(void*) ,void* args);
//thread:用来获取线程id
//attr:用来设置进程属性以及栈的大小，通常置为NULL;
//start_routine:线程的入口函数
//arg:传递给进程入口函数的参数
//返回值:0表示成功，！0表示不成功
#include <stdio.h>
    2 #include <unistd.h>
    3 #include <pthread.h>
    4 
    5 //线程创建，体会每个线程都是执行流
    6 void* thr_entry(void* arg)
    7 {
    8   while(1)
    9   {
   10     printf("i am common thread-----%s\n",(char*)arg);
   11     sleep(1);                                                                                                     
   12   }
   13   return NULL;
   14 }
   15 
   16 int main()
   17 {
   18   //int pthread_create(pthread_t *thread,const pthread_attr_t *attr,
   19   //void* (*start_routine)(void*),void* args)
   20   pthread_t tid;
W> 21   char* param = "this is input param";
   22   int ret = pthread_create(&tid,NULL,thr_entry,(void*)param);
   23   if(ret != 0)
24   {
   25     printf("pthread create error\n");
   26     return -1;
   27   }
W> 28   printf("tid:%p\n",tid);
   29   while(1)
   30   {
   31     printf("i am main thread-----\n");
   32     sleep(1);
   33   }
   34   return 0;
   35 }                                                                                                                 

ps -efL //可以查看轻量级进程
线程中的id讨论:
​tid : 线程地址空间首地址，方便用户操作线程
​pcd->pid 轻量级进程id（LWP）
pcb->tgid 进程（线程组）id，默认等于首线程地址id

线程终止

//return   不能在main函数中return（退出的是进程-----导致所有线程退出）
//void pthread_exit(void * retval);        退出线程自身，谁调用谁退出
​//retval:线程退出的返回值
//int pthread_cancel(pthread_t thread);取消其他线程，让其他线程退出
​//thread：要取消的线程ID
//线程退出后，默认不会自动释放资源，（保存自己的退出结果在线程独有的地址空间中），会造成资源泄露
//主线程退出，其他线程依然可以正常运行
    1 #include <stdio.h>                                                                                                
    2 #include <unistd.h>
    3 #include <pthread.h>
    4  
    5 void* thr_entry(void* arg)
    6 {
    7   //pthread_exit(NULL)退出当前线程
    8   pthread_cancel((pthread_t) arg);          
    9   pthread_t ctid;
   10   ctid = pthread_self();              
   11   while(1){                                                 
W> 12     printf("i am common pthread--------%p\n",ctid);
   13     sleep(1);
   14   }                                  
   15   return NULL;
   16 }  
   17 int main()               
   18 {                                    
   19   pthread_t mtid;
   20   mtid = pthread_self();//获取本线程的ip地址
   21   pthread_t tid;
W> 22   char* param = "this is input param";
   23   int ret = pthread_create(&tid,NULL,thr_entry,(void*)mtid);
      24   if(ret != 0)                                     
   25   {          
   26     printf("pthread create error\n");
   27     return -1;
   28   }
W> 29   printf("tid:%p\n",tid);
   30   //pthread_cancle(tid); 取消普通线程
   31   while(1){      
   32     printf("i am main thread-------\n");    
   33     sleep(1);   
   34   }                                   
   35 }                                                                                                                 

线程等待

概念：等待指定线程退出，获取这个线程的退出返回值，并回收这个线程的资源。
​ 一个线程有默认属性：joinable;处于joinable属性的线程退出后为了保存返回值，因此不会自动释放资源
​ 如果不进行等待会造成内存泄漏（一个线程只有处于joinable状态的时候，才需要被等待）
​ pthread_join(pthread_t tid,void **retval);

线程分离

是将线程的joinable属性修改为detach属性
​ 线程若处于detach属性，则线程退出后将自动回收资源；并且这个线程不需要等待，因为线程返回值占用的空间已经被回收。
pthread_detach(pthread_t tid)
线程分离的适用场景：
一进入自己的线程就线程等待：pthread_detach(pthread_self());

#include <stdio.h>
    2 #include <unistd.h>
    3 #include <errno.h>
    4 #include <pthread.h>
    5 
    6 //线程等待
    7 void* thr_entry(void* arg)
    8 {
    9   pthread_detach(pthread_self());
   10   sleep(3);
W> 11   char* ptr = "hello";
   12   pthread_exit(ptr);                                                                                              
   13   pthread_cancel((pthread_t)arg);
   14   while(1)
   15   {
   16     printf("i am common thread----%s\n",(char*)arg);
   17     sleep(1);
   18   }
   19 }
   20 
   21 int main()
   22 {
   23   pthread_t mtid;
#include <stdio.h>
    2 #include <unistd.h>
    3 #include <errno.h>
    4 #include <pthread.h>
    5 
    6 //线程等待
    7 void* thr_entry(void* arg)
    8 {
    9   pthread_detach(pthread_self());
   10   sleep(3);
W> 11   char* ptr = "hello";
   12   pthread_exit(ptr);                                                                                              
   13   pthread_cancel((pthread_t)arg);
   14   while(1)
   15   {
   16     printf("i am common thread----%s\n",(char*)arg);
   17     sleep(1);
   18   }
   19 }
   20 
   21 int main()
   22 {
   23   pthread_t mtid;

线程安全

多个线程同时对临界资源进行访问而不会造成数据二异性

如何实现线程安全：

​ 同步：时序合理性

​ 互斥：对临界资源同一时间的访问唯一性
线程间互斥实现：互斥锁

• 1.定义互斥锁变量

pthread_mutex_t

• 2.对互斥锁变量进行初始化

pthread_mutex_init(mutex,attr);
​//mutex : 互斥锁变量
​//attr: 初始化互斥锁属性---通常置NULL

• 3.对临界资源操作之前先加锁 [在对临界资源操作之前加锁],若可以加锁则直接修改计数，函数返回；否则挂起等待

pthread_mutex_lock(&mutex);
pthread_mutex_trylock   //  pthread_mutex_timedlock

• 4.对临界资源操作完毕后进行解锁 [在对临界资源操作之后立即解锁，线程退出之前也要解锁]

	pthread_mutex_unlock(&mutex)

5.销毁互斥锁

	pthread_mutex_destory(&mutex)

死锁：多个线程对锁资源进行竞争访问，但是因为推进顺序不当导致相互等待，以至于程序无法往下运行
死锁产生的四个必要条件
1.互斥条件：一个锁只有一个线程可以获取

2.不可剥夺条件：我上的锁别人不可以解

3.请求与保持条件：拿着A锁去请求B锁，若获取不到B锁，也不会释放A锁。

4.环路等待条件：A拿着A锁去请求B锁，B拿着B锁去请求A锁。

死锁预防：避免这4个必要条件
死锁避免：死锁检测算法，银行家算法

线程同步

线程同步的实现：等待+唤醒
操作不满足等待条件，别人促使等待条件满足后唤醒等待

条件变量：
条件变量实现同步：用户在对临界资源访问之前，先判断是否能够操作，若可以，线程直接操作；若不能，条件变量提供等待条件，让pcb在等待队列上。其他线程促使操作条件满足，唤醒条件变量等待队列上的线程。

1.定义条件变量：pthread_cond_t cond

2.条件变量初始化：pthread_cond_init(&cond,&attr)

3.用户在判断条件不满足的情况下提供等待功能 pthread_cond_wait(&cond,&mutex);
为什么条件变量要与互斥锁一起使用：线程什么时候等待，需要一个判断条件；这个判断条件也是临界资源（等待了之后，其他线程需要促使这个条件满足（修改临界资源））；因此这个临界资源的操作就需要受保护（默认使用互斥锁实现保护）

4..用户在促使条件满足条件后，唤醒等待 pthread_cond_signal （唤醒至少一个线程） 	        
pthread_cond_broadcast（唤醒所有线程）