Linux线程概念

1. Linux线程概念

什么是线程

在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列”

一切进程至少都有一个执行线程

线程在进程内部运行，本质是在进程地址空间内运行

在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化

透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程 执行流

一个进程内存存在多个线程？可能

进程：线程   1：n的关系，是操作系统中是否存在多个线程？操作肯定存在多的线程，那么操作系统要不要管理线程呢？肯定要管理，常规的操作系统的做法，比如Windos,要描述线程内核数据结构中有TCB的结构体（线程控制块），符合先描述在组织。但是linux用了更好的方法，只创建PCB，共享同一个地址空间（虚拟地址空间），所以linux其实没有线程的概念，只能说成是轻量级的进程。具体如下图：

既然在CPU看到的都是PCB(轻量级进程），那么linux操作系统内核中就没有专门为linux“线程”提供专门的接口，因为Linux的线程是用进程模拟的，而是给我们提供，在同一地址空间内创建PCB的方法（vfork），分配资源给指定的PBC接口，但是这种方法对用户确实不太友好的，而为了方便程序员使用“线程”这种机制，伟大的系统级别的工程师，在用户层，读linux的接口进行了封装，如创建线程，释放线程，等待线程...伟大的程序员们设计了一个原生库（我喜欢叫内裤），离操作系统最近的库pthread。具体如下图：

 2.线程的优点

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

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

线程占用的资源要比进程少很多

能充分利用多处理器的可并行数量

在等待慢速I/O操作结束的同时，程序可执行其他的计算任务

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

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

对于计算密集型例如：加密，大数据运算->主要使用CPU资源

对于I/O密集型例如：网络下载，云盘，ssh,在线直播，看电影->内存和外设的I/O资源

CPU+I/O密集型这样的应用：网络游戏

对于计算密集型：线程越多越好吗？

不一定，如果线程太多，会导致线程间被过度调度切换（有成本的）

对于I/O密集型应用：线程越多越好吗？

不一定，不过I/O允许多一些的线程，大部分时间就可以等待I/O就绪

 3.线程的缺点

性能损失

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

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

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

健壮性降低

编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了

不该共享的变量而造成不良影响的可能性是很大的，换句话说线程之间是缺乏保护的。

缺乏访问控制

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

编程难度提高

编写与调试一个多线程程序比单线程程序困难得多

线程异常

单个线程如果出现除零，野指针问题导致线程崩溃，进程也会随着崩溃

线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该进程内的所有线程也就随即退出  

线程用途

合理的使用多线程，能提高 CPU 密集型程序的执行效率

合理的使用多线程，能提高 IO 密集型程序的用户体验（如生活中我们一边写代码一边下载开发工具，就是 多线程运行的一种表现）

4.Linux进程VS线程

进程和线程

进程是资源分配的基本单位

线程是调度的基本单位

线程共享进程数据，但也拥有自己的一部分数据:

线程ID

一组寄存器

栈

errno

信号屏蔽字

调度优先级

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

文件描述符表

每种信号的处理方式(SIG_ IGN、SIG_ DFL或者自定义的信号处理函数)

当前工作目录

用户id和组id

进程和线程的关系如下图:

5.Linux线程控制

POSIX线程库        

与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的

要使用这些函数库，要通过引入头文<pthread.h>

链接这些线程函数库时要使用编译器命令的“-lpthread”选项

1.创建线程

功能：创建一个新的线程 原型 
int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void * (*start_routine)(void*), void *arg); 
参数 
 thread:返回线程ID
 attr:设置线程的属性，attr为NULL表示使用默认属性
 start_routine:是个函数地址，线程启动后要执行的函数
 arg:传给线程启动函数的参数
 返回值：成功返回0；失败返回错误码

错误检查:

传统的一些函数是，成功返回 0 ，失败返回 -1 ，并且对全局变量 errno 赋值以指示错误。

pthreads 函数出错时不会设置全局变量 errno （而大部分其他 POSIX 函数会这样做）。而是将错误代码通 过返回值返回

pthreads 同样也提供了线程内的 errno 变量，以支持其它使用 errno 的代码。对于 pthreads 函数的错误，

建议通过返回值判定，因为读取返回值要比读取线程内的 errno 变量的开销更小

#include<iostream>
using namespace std;
#include<unistd.h>
#include<pthread.h>
#include<stdlib.h>
#include<string.h>
void *pthread_run(void *args)
{
        char *str = (char*)args;
        while(1)
        {
                cout<<str<<endl;
                sleep(1);
        }
}
int main()
{
        pthread_t id;
        int ret = pthread_create(&id,nullptr,pthread_run,(void *)"new pthread");
        if(ret != 0)
        {
                fprintf(stderr,"pthread_create:%s\n",strerror(ret));
                exit(1);
        }
        while(1)
        {
                cout<<"i am main pthreand"<<endl;
                sleep(1);
        }
}

2.线程ID及进程地址空间布局

pthread_ create 函数会产生一个线程 ID ，存放在第一个参数指向的地址中。该线程 ID 和前面说的线程 ID 不是一回事。

前面讲的线程 ID 属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要 一个数值来唯一表示该线程。

pthread_ create 函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程 ID ， 属于NPTL 线程库的范畴。线程库的后续操作，就是根据该线程 ID 来操作线程的。

线程库 NPTL 提供了 pthread_ self 函数，可以获得线程自身的 ID ：

#include<iostream>
using namespace std;
#include<unistd.h>
#include<pthread.h>
#include<stdlib.h>
#include<string.h>
void *pthread_run(void *args)
{
        char *str = (char*)args;
        while(1)
        {
                cout<<str<<":"<<pthread_self()<<endl;
                sleep(1);
        }
}
int main()
{
        pthread_t id;
        int ret = pthread_create(&id,nullptr,pthread_run,(void *)"new pthread");
        if(ret != 0)
        {
                fprintf(stderr,"pthread_create:%s\n",strerror(ret));
                exit(1);
        }
        while(1)
        {
                cout<<"i am main pthreand"<<":"<<pthread_self()<<endl;
                sleep(1);
        }
}

 可以看出操作系统表示线程的是LWP,而用户的是一个地址

 所以用户只要拿到这个地址就可以找到对应的线程的地址空间

3.线程终止

如果需要只终止某个线程而不终止整个进程 , 可以有三种方法：

1. 从线程函数 return 。这种方法对主线程不适用 , 从 main 函数 return 相当于调用 exit 。

2. 线程可以调用 pthread_ exit 终止自己。

3. 一个线程可以调用 pthread_ cancel 终止同一进程中的另一个线程。

pthread_exit函数功能：线程终止

原型

void pthread_exit(void *value_ptr);

参数

value_ptr:value_ptr 不要指向一个局部变量。

返回值：无返回值，跟进程一样，线程结束的时候无法返回到它的调用者（自身）

需要注意 ,pthread_exit 或者 return 返回的指针所指向的内存单元必须是全局的或者是用 malloc 分配的 , 不能在线程函 数的栈上分配, 因为当其它线程得到这个返回指针时线程函数已经退出了。

#include<iostream>
using namespace std;
#include<unistd.h>
#include<pthread.h>
#include<stdlib.h>
#include<string.h>
void *pthread_run(void *args)
{
        char *str = (char*)args;
        while(1)
        {
                cout<<str<<":"<<pthread_self()<<endl;
                sleep(10);
                pthread_exit(nullptr);
        }
}
int main()
{
        pthread_t id;
        int ret = pthread_create(&id,nullptr,pthread_run,(void *)"new pthread");
        if(ret != 0)
        {
                fprintf(stderr,"pthread_create:%s\n",strerror(ret));
                exit(1);
        }
        while(1)
        {
                cout<<"i am main pthreand"<<":"<<pthread_self()<<endl;
                sleep(1);
        }
}

 我们可以看出新线程在10秒之后退出，只有主线程在跑，那接下来我们在10秒之后关闭主线程有什么结果呢

#include<iostream>
using namespace std;
#include<unistd.h>
#include<pthread.h>
#include<stdlib.h>
#include<string.h>
void *pthread_run(void *args)
{
        char *str = (char*)args;
        while(1)
        {
                cout<<str<<":"<<pthread_self()<<endl;
                sleep(1);
        }
}
int main()
{
        pthread_t id;
        int ret = pthread_create(&id,nullptr,pthread_run,(void *)"new pthread");
        if(ret != 0)
        {
                fprintf(stderr,"pthread_create:%s\n",strerror(ret));
                exit(1);
        }
        while(1)
        {
                cout<<"i am main pthreand"<<":"<<pthread_self()<<endl;
                sleep(10);

                pthread_exit(nullptr);
        }
}

我们可以看出新线程变成了僵尸（defunct）

4.pthread_cancel函数

功能：取消一个执行中的线程

原型

int pthread_cancel(pthread_t thread);

参数

thread: 线程 ID

返回值：成功返回 0 ；失败返回错误码

#include<iostream>
using namespace std;
#include<unistd.h>
#include<pthread.h>
#include<stdlib.h>
#include<string.h>
void *pthread_run(void *args)
{
        char *str = (char*)args;
        while(1)
        {
                cout<<str<<":"<<pthread_self()<<endl;
                sleep(10);
                pthread_cancel(pthread_self());
        }
}
int main()
{
        pthread_t id;
        int ret = pthread_create(&id,nullptr,pthread_run,(void *)"new pthread");
        if(ret != 0)
        {
                fprintf(stderr,"pthread_create:%s\n",strerror(ret));
                exit(1);
        }
        while(1)
        {
                cout<<"i am main pthreand"<<":"<<pthread_self()<<endl;
                sleep(10);

                //pthread_exit(nullptr);
        }
}

 5.等待线程结束

功能：等待线程结束

原型

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

参数

thread : 线程 ID

value_ptr : 它指向一个指针，后者指向线程的返回值

返回值：成功返回 0 ；失败返回错误码

调用该函数的线程将挂起等待 , 直到 id 为 thread 的线程终止。 thread 线程以不同的方法终止 , 通过 pthread_join 得到的 终止状态是不同的，总结如下

1. 如果 thread 线程通过 return 返回 ,value_ ptr 所指向的单元里存放的是 thread 线程函数的返回值。

2. 如果 thread 线程被别的线程调用 pthread_ cancel 异常终掉 ,value_ ptr 所指向的单元里存放的是常数

PTHREAD_ CANCELED 。

3. 如果 thread 线程是自己调用 pthread_exit 终止的 ,value_ptr 所指向的单元存放的是传给 pthread_exit 的参

数。

4. 如果对 thread 线程的终止状态不感兴趣 , 可以传 NULL 给 value_ ptr 参数

        

 6.分离线程

默认情况下，新创建的线程是 joinable 的，线程退出后，需要对其进行 pthread_join 操作，否则无法释放 资源，从而造成系统泄漏。

如果不关心线程的返回值， join 是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源。

int pthread_detach(pthread_t thread);

可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离 :

pthread_detach(pthread_self());

#include<iostream>
using namespace std;
#include<unistd.h>
#include<pthread.h>
#include<stdlib.h>
#include<string.h>
void *pthread_run(void *args)
{
        char *str = (char*)args;
                cout<<str<<":"<<pthread_self()<<endl;
                sleep(5);
                pthread_detach(pthread_self());
                //pthread_cancel(pthread_self());
}
int main()
{
        pthread_t id;
        int ret = pthread_create(&id,nullptr,pthread_run,(void *)"new pthread");
        if(ret != 0)
        {
                fprintf(stderr,"pthread_create:%s\n",strerror(ret));
                exit(1);
        }
                cout<<"i am main pthreand"<<":"<<pthread_self()<<endl;
                sleep(10);
                pthread_join(id,nullptr);
                //pthread_exit(nullptr);
}