Linux中的线程

一. 概念 

  首先Linux并不存在真正的线程，Linux的线程是使用进程模拟的。当我们需要在一个进程中同时运行多个执行流时，我们并不可以开辟多个进程执行我们的操作（32位机器里每个进程认为它 独享 4G的内存资源），此时便引入了线程，例如当我们既需要下载内容，又需要浏览网页时，此时多线程便起了作用。线程是承担调度的基本单位，一个进程可拥有多个线程，它的执行力度比进程更加细致，线程资源共享。 

     在linux下，线程就是进程（轻量级进程），在程序员看来，进程和线程确实不一样，因为线程没有自己的地址空间，多个线程是共用地址空间的，但是对于内核来说，它关注的是pcb，线程创造出来有各自的pcb，所以内核分不清进程和线程，线程就是进程。

一个进程的虚拟内存是4G，在Linux32位平台下，内核分走了1G，留给用户用的只有3G，于是我们可以想到，创建一个线程占有了10M内存，总共有3G内存可以使用。于是可想而知，最多可以创建差不多300个左右的线程。 

有了进程，为什么还要有线程？

程产生的原因：

进程可以使多个程序能并发执行，以提高资源的利用率和系统的吞吐量；但是其具有一些缺点：

• 进程在同一时间只能干一件事
• 进程在执行的过程中如果阻塞，整个进程就会挂起，即使进程中有些工作不依赖于等待的资源，仍然不会执行。

因此，操作系统引入了比进程粒度更小的线程，作为并发执行的基本单位，从而减少程序在并发执行时所付出的时空开销，提高并发性。和进程相比，线程的优势如下：

从资源上来讲，线程是一种非常"节俭"的多任务操作方式。在linux系统下，启动一个新的进程必须分配给它独立的地址空间，建立众多的数据表来维护它的代码段、堆栈段和数据段，这是一种"昂贵"的多任务工作方式。

从切换效率上来讲，运行于一个进程中的多个线程，它们之间使用相同的地址空间，而且线程间彼此切换所需时间也远远小于进程间切换所需要的时间。据统计，一个进程的开销大约是一个线程开销的30倍左右。

从通信机制上来讲，线程间方便的通信机制。对不同进程来说，它们具有独立的数据空间，要进行数据的传递只能通过进程间通信的方式进行，这种方式不仅费时，而且很不方便。线程则不然，由于同一进城下的线程之间贡献数据空间，所以一个线程的数据可以直接为其他线程所用，这不仅快捷，而且方便。

二. 特点 

pthread_create的时候，地址空间并未发生变化（而fork的时候会赋值一份地址空间），进程退化成了线程（此时也就是主线程），创造出的子线程和主线程共用地址空间，可以想象成一间屋子夫妻生孩子以后一起住。不一样的地方是pcb有两个，主线程和子线程有各自独立的pcb,子线程的pcb是从主线程拷贝而来的，所以说创建子线程后地址空间并未没有变化，只不过内核区的pcb多出来一份。

由于同一进程的多个线程共享同一地址空间,所以代码段，数据段是共享的,如果定义一个函数（存储在代码段）,各线程都可以进行调用,如果定义个全局变量（存储在数据段）,在各线程中都可以访问到,除此之外,各线程还共享以下进程资源和环境: 

1.文件描述符表 
2. .text
3. .bss
4. .data
5. 堆
6. 动态库加载区
7. 环境变量

8. 命令行参数

所以线程间通信可以使用堆和全局变量

但有些资源是线程独享的： 

1.线程ID
      每个线程都有自己的线程ID，这个ID在本进程中是唯一的。进程用此来标识线程。

2.寄存器组的值
      由于线程间是并发运行的，每个线程有自己不同的运行线索，当从一个线程切换到另一个线程上 时，必须将原有的线程的寄存器集合的状态保存，以便将来该线程在被重新切换到时能得以恢复。

3.线程的堆栈
      堆栈是保证线程独立运行所必须的。线程函数可以调用函数，而被调用函数中又是可以层层嵌套的，所以线程必须拥有自己的函数堆栈， 使得函数调用可以正常执行，不受其他线程的影响。

4.错误返回码
      由于同一个进程中有很多个线程在同时运行，可能某个线程进行系统调用后设置了errno值，而在该 线程还没有处理这个错误，另外一个线程就在此时被调度器投入运行，这样错误值就有可能被修改。所以，不同的线程应该拥有自己的错误返回码变量。

5.线程的信号屏蔽码
      由于每个线程所感兴趣的信号不同，所以线程的信号屏蔽码应该由线程自己管理。但所有的线程都 共享同样的信号处理器。

6.线程的优先级
      由于线程需要像进程那样能够被调度，那么就必须要有可供调度使用的参数，这个参数就是线程的 优先级。

线程需要保存哪些上下文，SP、PC、EAX这些寄存器是干嘛用的

堆栈指针SP,堆栈指针，随时跟踪栈顶地址，按"先进后出"的原则存取数据。

程序计数器PC，程序计数器是用于存放下一条指令所在单元的地址的地方。

累加器寄存器EAX，累加器是专门存放算术或逻辑运算的一个操作数和运算结果的寄存器。能进行加、减、读出、移位、循环移位和求补等操作。是运算器的主要部分。

三、察看指定线程的LWP号

线程号和线程ID是有区别的
线程号是给内核看的
查看方式：
找到程序的进程ID

ps -Lf pid

四、进程与线程的区别

1.线程是程序执行的最小单位，而进程是操作系统分配资源的最小单位；

2.一个进程由一个或多个线程组成，线程是一个进程中代码的不同执行路线；

3.进程之间相互独立，但同一进程下的各个线程之间共享程序的内存空间(包括代码段、数据集、堆等)及一些进程级的资源(如打开文件和信号)，某进程内的线程在其它进程不可见；

4.系统开销，创建和撤销进程时，系统都要为之分配或回收资源，如内存空间、IO设备等，因此操作系统所付出的开销远大于创建或撤销线程的开销。类似地，在进程切换时，涉及当前执行进程CPU环境的保存以及新调度的进程CPU环境的设置；而线程却还时只需要保存和设置少量寄存器内容，因此，开销较小。

5。通信方面，进程间通信需要借助操作系统，而线程间可以直接读/写进程数据段（如全局变量）来进行通信。

五、线程相关函数

1. 创建线程 -- pthread_create

函数原型:

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

参数: 

thread: 传出参数, 线程创建成功之后,会被设置一个合适的值
attr: 默认传NULL
start_routine: 子线程的处理函数

arg: 回调函数的参数

返回值：

成功返回0。失败返回错误号

pthread_create如何传递两个参数以上的参数

涉及多参数传递给线程的，都需要使用结构体将参数封装后，将结构体指针传给线程。定义一个结构体。将这个结构体指针，作为void *形参的实际参数传递。

struct mypara
{
    var para1;//参数1
    var para2;//参数2
} 

 将这个结构体指针，作为void *形参的实际参数传递。

struct mypara pstru;
pthread_create(&ntid, NULL, thr_fn,& (pstru)); 

 函数中需要定义一个mypara类型的结构指针来引用这个参数。

void *thr_fn(void *arg)
{
    mypara *pstru;
    pstru = (struct mypara *) arg;
    pstru->para1;//参数1
    pstru->para2;//参数2
}

2. 单个线程退出 -- pthread_exit

函数原型:

void pthread_exit(void *retval);

参数：

retval：读取线程退出的时候携带的状态信息

3. 阻塞等待线程退出, 获取线程退出状态 -- pthread_join

 函数原型:

int pthread_join(pthread_t thread, void **retval);

参数：

thread：要回收的子线程的线程id
retval：读取线程退出的时候携带的状态信息
传出参数：void* ptr；

     指向的内存和pthread_exit参数指向同一块内存地址

4. 线程分离 -- pthread_detach

函数原型:

int pthread_detach(pthread_t thread);

 调用该函数之后不需要pthread_join

○子线程会自动回收自己的pcb

5. 杀死(取消)线程 -- pthread_cancel

函数原型:  

int pthread_cancel(pthread_t thread);

使用注意事项:

§ 在要杀死的子线程对应的处理的函数的内部, 必须做过一次系统调用.
□ pthread_testcancel();   //设置一个取消点，无实际意义
§ write read printf
§ int a；
§ a = 2；
§ int b = a+3；

6. 比较两个线程ID是否相等(预留函数) -- pthread_equal

 函数原型: 

int pthread_equal(pthread_t t1, pthread_t t2);

六、多线程和多进程

多线程的优点：

无需跨进程边界； 程序逻辑和控制方式简单； 所有线程可以直接共享内存和变量等； 线程方式消耗的总资源比进程方式好； 

多线程缺点：

每个线程与主程序共用地址空间，受限于2GB地址空间； 线程之间的同步和加锁控制比较麻烦； 一个线程的崩溃可能影响到整个程序的稳定性； 到达一定的线程数程度后，即使再增加CPU也无法提高性能

多进程优点：

每个进程互相独立，不影响主程序的稳定性，子进程崩溃没关系； 通过增加CPU，就可以容易扩充性能； 可以尽量减少线程加锁/解锁的影响，极大提高性能，就算是线程运行的模块算法效率低也没关系； 每个子进程都有2GB地址空间和相关资源，总体能够达到的性能上限非常大 

多进程缺点：

逻辑控制复杂，需要和主程序交互； 需要跨进程边界，如果有大数据量传送，就不太好，适合小数据量传送、密集运算 多进程调度开销比较大； 

对比维度	多进程	多线程	总结
数据共享、同步	数据共享复杂，需要用IPC；数据是分开的，同步简单	因为共享进程数据，数据共享简单，但也是因为这个原因导致同步复杂	各有优势
内存、CPU	占用内存多，切换复杂，CPU利用率低	占用内存少，切换简单，CPU利用率高	线程占优
创建销毁、切换	创建销毁、切换复杂，速度慢	创建销毁、切换简单，速度很快	线程占优
编程、调试	编程简单，调试简单	编程复杂，调试复杂	进程占优
可靠性	进程间不会互相影响	一个线程挂掉将导致整个进程挂掉	进程占优

进程切换分两步：

1.切换页目录以使用新的地址空间

2.切换内核栈和硬件上下文

对于linux来说，线程和进程的最大区别就在于地址空间，对于线程切换，第1步是不需要做的，第2是进程和线程切换都要做的。

切换的性能消耗：

1、线程上下文切换和进程上下问切换一个最主要的区别是线程的切换虚拟内存空间依然是相同的，但是进程切换是不同的。这两种上下文切换的处理都是通过操作系统内核来完成的。内核的这种切换过程伴随的最显著的性能损耗是将寄存器中的内容切换出。

2、另外一个隐藏的损耗是上下文的切换会扰乱处理器的缓存机制。简单的说，一旦去切换上下文，处理器中所有已经缓存的内存地址一瞬间都作废了。还有一个显著的区别是当你改变虚拟内存空间的时候，处理的页表缓冲（processor's Translation Lookaside Buffer (TLB)）或者相当的神马东西会被全部刷新，这将导致内存的访问在一段时间内相当的低效。但是在线程的切换中，不会出现这个问题。

看一下其他人的描述

多线程和多进程的选择

单线程和多线程的比较：

线程切换代价很少，线程是可以共享内存的。所以采用多线程在切换上花费的比多进程少得多。但是，线程切换还是需要时间消耗的，所以采用一个拥有两个线程的进程执行所需要的时间比一个线程的进程执行两次所需要的时间要多一些。即采用多线程不会提高程序的执行速度，反而会降低速度，但是对于用户来说，可以减少用户的响应时间（相当于雨露均沾，都先给点甜头，但是来回切换就影响了效率）。上述结果只是针对单CPU，如果对于多CPU或者CPU采用超线程技术的话，采用多线程技术还是会提高程序的执行速度的。因为单线程只会映射到一个CPU上，而多线程会映射到多个CPU上，超线程技术本质是多线程硬件化，所以也会加快程序的执行速度。

七、几种线程间的通信机制

1、锁机制

     1.1 互斥锁：提供了以排它方式阻止数据结构被并发修改的方法。

     1.2 读写锁：允许多个线程同时读共享数据，而对写操作互斥。

     1.3 条件变量：可以以原子的方式阻塞进程，直到某个特定条件为真为止。对条件测试是在互斥锁的保护下进行的。条件变量始终与互斥锁一起使用。

2、信号量机制：包括无名线程信号量与有名线程信号量

3、信号机制：类似于进程间的信号处理。

线程间通信的主要目的是用于线程同步，所以线程没有象进程通信中用于数据交换的通信机制。

八、什么是多线程上下文切换

即使是单核CPU也支持多线程执行代码，CPU通过给每个线程分配CPU时间片来实现这个机制。时间片是CPU分配给各个线程的时间，因为时间片非常短，所以CPU通过不停地切换线程执行，让我们感觉多个线程时同时执行的，时间片一般是几十毫秒（ms）。

CPU通过时间片分配算法来循环执行任务，当前任务执行一个时间片后会切换到下一个任务。但是，在切换前会保存上一个任务的状态，以便下次切换回这个任务时，可以再次加载这个任务的状态，从任务保存到再加载的过程就是一次上下文切换。

这就像我们同时读两本书，当我们在读一本英文的技术书籍时，发现某个单词不认识， 于是便打开中英文词典，但是在放下英文书籍之前，大脑必须先记住这本书读到了多少页的第多少行，等查完单词之后，能够继续读这本书。这样的切换是会影响读 书效率的，同样上下文切换也会影响多线程的执行速度。

九、用户级线程和内核级线程

线程的实现可以分为两类：用户级线程和内核级线程。内核级线程又称为内核支持的线程。

用户线程指不需要内核支持而在用户程序中实现的线程，其不依赖于操作系统核心，应用进程利用线程库提供创建、同步、调度和管理线程的函数来控制用户线程。不需要用户态/核心态切换，速度快，操作系统内核不知道多线程的存在，因此一个线程阻塞将使得整个进程（包括它的所有线程）阻塞。由于这里的处理器时间片分配是以进程为基本单位，所以每个线程执行的时间相对减少。

内核线程：由操作系统内核创建和撤销。内核维护进程及线程的上下文信息以及线程切换。一个内核线程由于I/O操作而阻塞，不会影响其它线程的运行。Windows NT和2000/XP支持内核线程。

用户线程运行在一个中间系统上面。目前中间系统实现的方式有两种，即运行时系统（Runtime System）和内核控制线程。“运行时系统”实质上是用于管理和控制线程的函数集合，包括创建、撤销、线程的同步和通信的函数以及调度的函数。这些函数都驻留在用户空间作为用户线程和内核之间的接口。用户线程不能使用系统调用，而是当线程需要系统资源时，将请求传送给运行时，由后者通过相应的系统调用来获取系统资源。内核控制线程：系统在分给进程几个轻型进程（LWP），LWP可以通过系统调用来获得内核提供的服务，而进程中的用户线程可通过复用来关联到LWP，从而得到内核的服务。

以下是用户级线程和内核级线程的区别：

（1）内核支持线程是OS内核可感知的，而用户级线程是OS内核不可感知的。

（2）用户级线程的创建、撤消和调度不需要OS内核的支持，是在语言（如Java）这一级处理的；而内核支持线程的创建、撤消和调度都需OS内核提供支持，而且与进程的创建、撤消和调度大体是相同的。

（3）用户级线程执行系统调用指令时将导致其所属进程被中断，而内核支持线程执行系统调用指令时，只导致该线程被中断。

（4）在只有用户级线程的系统内，CPU调度还是以进程为单位，处于运行状态的进程中的多个线程，由用户程序控制线程的轮换运行；在有内核支持线程的系统内，CPU调度则以线程为单位，由OS的线程调度程序负责线程的调度。

（5）用户级线程的程序实体是运行在用户态下的程序，而内核支持线程的程序实体则是可以运行在任何状态下的程序。

内核线程的优点：

（1）当有多个处理机时，一个进程的多个线程可以同时执行。

缺点：

（1）由内核进行调度。

用户线程的优点：

（1） 线程的调度不需要内核直接参与，控制简单。

（2） 可以在不支持线程的操作系统中实现。

（3） 创建和销毁线程、线程切换代价等线程管理的代价比内核线程少得多。

（4） 允许每个进程定制自己的调度算法，线程管理比较灵活。

（5） 线程能够利用的表空间和堆栈空间比内核级线程多。

（6） 同一进程中只能同时有一个线程在运行，如果有一个线程使用了系统调用而阻塞，那么整个进程都会被挂起。另外，页面失效也会产生同样的问题。

缺点：

（1）资源调度按照进程进行，多个处理机下，同一个进程中的线程只能在同一个处理机下分时复用

十、常见线程模型

1.fork&join模型

该模型包含递归思想和回溯思想，递归用来拆分任务，回溯用合并结果。可以用来处理一些可以进行拆分的大任务。其主要是把一个大任务逐级拆分为多个子任务，然后分别在子线程中执行，当每个子线程执行结束之后逐级回溯，返回结果进行汇总合并，最终得出想要的结果。

这里模拟一个摘苹果的场景：有100棵苹果树，每棵苹果树有10个苹果，现在要把他们摘下来。为了节约时间，规定每个线程最多只能摘10棵苹树以便于节约时间。各个线程摘完之后汇总计算总苹果树。

2.生产者消费者模型

生产者消费者模型都比较熟悉，其核心是使用一个缓存来保存任务。开启一个/多个线程来生产任务，然后再开启一个/多个来从缓存中取出任务进行处理。这样的好处是任务的生成和处理分隔开，生产者不需要处理任务，只负责向生成任务然后保存到缓存。而消费者只需要从缓存中取出任务进行处理。使用的时候可以根据任务的生成情况和处理情况开启不同的线程来处理。比如，生成的任务速度较快，那么就可以灵活的多开启几个消费者线程进行处理，这样就可以避免任务的处理响应缓慢的问题。

3.master-worker模型(线程池应该就是属于此种类型)

master-worker模型类似于任务分发策略，开启一个master线程接收任务，然后在master中根据任务的具体情况进行分发给其它worker子线程，然后由子线程处理任务。如需返回结果，则worker处理结束之后把处理结果返回给master。