目录
什么是线程
1.在一个程序里的一个执行路线就叫做线程（thread）。更准确的定义是：线程是“一个进程内部的控制序列” 。
2.一切进程至少都有一个执行线程。
3.线程在进程内部运行，本质是在进程地址空间内运行。
4.在Linux系统中，在CPU眼中，看到的PCB都要比传统的进程更加轻量化。
5.透过进程虚拟地址空间，可以看到进程的大部分资源，将进程资源合理分配给每个执行流，就形成了线程执行流。
当一个可执行程序被运行时，OS会创建并管理相应的进程控制块（task_struct)、进程地址空间（mm_struct)以及建立记录虚拟地址空间到物理地址空间的映射关系的页表。但如果我们在这个进程里，再创建一个task_struct，并要求创建出来的task_struct和父task_struct共享部分的进程地址空间和页表，那么创建的结果就是下面这样的。jl
如上图我们可以理解一个进程在运行时创建了3个线程，这时这个可执行程序在运行时就有了4个执行流，因为线程和进程是操作系统中两个基本的执行单位，创建好的线程与进程共享部分或全部资源。进程是系统进行资源分配和调度的基本单位，而线程则是进程中的执行单元，是CPU调度和执行程序的最小单位。多个线程可以存在于同一个进程中，并共享进程的资源，本质是进程创建线程，线程在进程内部运行。例如内存空间、文件句柄、网络连接等。这意味着，多个线程可以同时访问同一个进程的资源，从而提高了程序的并发性和效率。
与进程相比，线程的创建、销毁和切换都要比进程更加轻量级和快速，因此线程通常被用来实现并发性和异步编程。同时，由于线程共享进程的资源，需要注意线程之间的同步和协调，避免数据竞争和死锁等问题。
如何重新理解之前的进程？
进程和线程都是可以直接被CPU调度的，所以CPU并不能识别当前调度的task_strult是进程还是线程，CPU关心的是 一个一个的执行流，它是以task_struct为单位进行调度的。因此，所谓的进程不是通过task_struct来衡量的，除task_struct 之外，进程由进程地址空间，网络连接等资源构成。
在Linux中，线程的控制块和进程的控制块是类似的，所以在Linux操作系统中，对进程和线程的管理使用的是同一套管理方式，线程的管理直接复用了进程控制块。如果一款操作系统要支持真的线程，那就要对线程进行管理，对线程的创建、终止、调度、切换、资源、分配、资源释放以及回收等进行管理，这就会使得操作系统变得复杂，例如windows。
在Linux没有真正意义的线程，也就绝对没有真正意义上的线程相关的系统调用！但是Linux可以提供创建轻量级进程的接口，也就是创建进程，共享空间，其中最典型的代表就是vfork函数。
vfork函数的功能就是创建子进程，但是父子共享空间，vfork的函数原型如下：
pid_t vfork(void);vfork函数的返回值与fork函数的返回值相同：
给父进程返回子进程的PID。
给子进程返回0。
只不过vfork函数创建出来的子进程与其父进程共享地址空间，例如在下面的代码中，父进程使用vfork函数创建子进程，子进程将全局变量g_val由1000改为了2000，父进程休眠3秒后再读取到全局变量g_val的值。
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
int g_val=1000;
int main()
{
pid_t vid=vfork();
if(vid==0)
{
//子进程
g_val=2000;
printf("我是子进程,pid：%d,ppid:%d,g_val:%d\n",getpid(),getppid(),g_val);
exit(0);
}
//父进程
sleep(3);
printf("我是父进程,pid：%d,ppid:%d,g_val:%d\n",getpid(),getppid(),g_val);
return 0;
}
在Linux中，虽然在内核角度没有真正意义上线程相关的接口，但是站在用户角度，当用户想创建一个线程时更期望使用thread_create这样类似的接口，而不是vfork函数，因此系统为用户层提供了原生线程库pthread。因为原生线程库实际是对轻量级进程的系统调用进行了封装，在用户层模拟实现了一套线程相关的接口。因此对于我们来讲，在Linux下学习线程实际上就是学习在用户层模拟实现的这一套接口，而并非操作系统的接口。
创建一个新线程的代价要比创建一个新进程小得多。
与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多。
线程占用的资源要比进程少很多。
能充分利用多处理器的可并行数量。
在等待慢速IO操作结束的同时，程序可执行其他的计算任务。
计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现。
IO密集型应用，为了提高性能，将IO操作重叠，线程可以同时等待不同的IO操作。
计算密集型：在执行流的大部分任务，主要以计算为主。比如加密解密、大数据查找等。
IO密集型：执行流的大部分任务，主要以IO为主。比如刷磁盘、访问数据库、访问网络等。
性能损失： 一个很少被外部事件阻塞的计算密集型线程往往无法与其他线程共享同一个处理器。如果计算密集型线程的数量比可用的处理器多，那么可能会有较大的性能损失，这里的性能损失指的是增加了额外的同步和调度开销，而可用的资源不变。
健壮性降低： 编写多线程需要更全面更深入的考虑，在一个多线程程序里，因时间分配上的细微偏差或者因共享了不该共享的变量而造成不良影响的可能性是很大的，换句话说，线程之间是缺乏保护的。
缺乏访问控制： 进程是访问控制的基本粒度，在一个线程中调用某些OS函数会对整个进程造成影响。
编程难度提高： 编写与调试一个多线程程序比单线程程序困难得多。
单个线程如果出现除零、野指针等问题导致线程崩溃，进程也会随着崩溃。
线程是进程的执行分支，线程出异常，就类似进程出异常，进而触发信号机制，终止进程，进程终止，该进程内的所有线程也就随即退出。
合理的使用多线程，能提高CPU密集型程序的执行效率。
合理的使用多线程，能提高IO密集型程序的用户体验（如生活中我们一边写代码一边下载开发工具，就是多线程运行的一种表现）。
进程和线程
进程是资源分配的基本单位
线程是调度的基本单位
线程共享进程数据，但也拥有自己的一部分数据:
线程ID
一组寄存器
栈
errno
信号屏蔽字
调度优先级
进程的多个线程共享 同一地址空间,因此Text Segment、Data Segment都是共享的,如果定义一个函数,在各线程
中都可以调用,如果定义一个全局变量,在各线程中都可以访问到,除此之外,各线程还共享以下进程资源和环境:
文件描述符表
每种信号的处理方式(SIG_ IGN、SIG_ DFL或者自定义的信号处理函数)
当前工作目录
用户id和组id
进程和线程的关系如下图:
POSIX线程库
与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以“pthread_”打头的。
要使用这些函数库，要通过引入头文。
链接这些线程函数库时要使用编译器命令的“-lpthread”选项。
原型
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>
#include <pthread.h>
#include <unistd.h>
using namespace std;
void *threadRun1(void *args)
{
while (true)
{
sleep(1);
cout<<"新线程"<<endl;
}
}
int main()
{
pthread_t t1;
pthread_create(&t1, nullptr, threadRun1, nullptr);
while (true)
{
sleep(1);
cout<<"主线程"<<endl;
}
}
makefile
mypthread:mypthread.cc
g++ -o $@ $^ -std=c++11 -lpthread
.PHONY:clean
clean:
rm -f mypthread
其中，LWP（Light Weight Process）就是轻量级进程的ID，可以看到显示的两个轻量级进程的PID是相同的，因为它们属于同一个进程。
注意： 在Linux中，应用层的线程与内核的LWP是一一对应的，实际上操作系统调度的时候采用的是LWP，而并非PID，只不过我们之前接触到的都是单线程进程，其PID和LWP是相等的，所以对于单线程进程来说，调度时采用PID和LWP是一样的。
为了进一步证明这两个线程是属于同一个进程的，我们可以让主线程和新线程在执行打印操作时，将自己的PID和PPID也进行打印。
#include <iostream>
#include <pthread.h>
#include <unistd.h>
using namespace std;
void *threadRun1(void *args)
{
while (true)
{
sleep(1);
cout<<endl;
cout<<"新线程 ... pid:"<<getpid()<<" ppid:" << getppid()<<endl;
}
}
int main()
{
pthread_t t1;
pthread_create(&t1, nullptr, threadRun1, nullptr);
while (true)
{
sleep(1);
cout<<endl;
cout<<"主线程 ... pid:"<<getpid()<<" ppid:" << getppid()<<endl;
}
}
让主线程创建一批线程
创建好的线程都调用threadRun1函数，也就是说创建好的线程会同时进入threadRun1函数即threadRun1函数被重入。
#include <unistd.h>
#include<sys/types.h>
#include <iostream>
#include <pthread.h>
#include <unistd.h>
#include<sys/types.h>using namespace std;
void* threadRun1(void* arg)
{
char* msg = (char*)arg;
while (true)
{
sleep(1);
cout << endl;
cout << "我是线程" << msg << "getpid: " << getpid() << "ppid:" << getppid() << endl;
}
}
int main()
{
pthread_t tid[5];
for (int i = 0; i < 5; i++)
{
char* buffer = (char*)malloc(64);
sprintf(buffer, ":%d", i);
pthread_create(&tid[i], nullptr, threadRun1, buffer);
}
while (true)
{
sleep(1);
cout << endl;
cout << "我是主线程pid:" << getpid() << "ppid:" << getppid() << endl;
}
return 0;
}
我们可以看到在这一批线程中只有一个线程的PID和LWP是相同的。
常见获取线程ID的方式有两种：
创建线程时通过输出型参数获得。
通过调用pthread_self函数获得。
pthread_self函数的函数原型：
pthread_t pthread_self(void);
调用pthread_self函数即可获得当前线程的ID，类似于调用getpid函数获取当前进程的ID。
例如，下面代码中在每一个新线程被创建后，主线程都将通过输出型参数获取到的线程ID进行打印，此后主线程和新线程又通过调用pthread_self函数获取到自身的线程ID进行打印。
#include<stdio.h> #include<stdlib.h> #include<sys/types.h> #include<unistd.h> #include<pthread.h> void*tineRou(void*arg) { char*msg=(char*)arg; while(1) { printf("我是线程: %s ...pid:%d, ppid:%d , tid:%lu\n",msg,getpid(),getppid(),pthread_self()); sleep(1); } } int main() { pthread tid[5]; for(int i=0;i<5;i++) { char* buffer=(char*)malloc(64); sprintf(buffer," 线程:%d ",i); pthread_create(&tid[i],NULL,tineRou,buffer); printf("%s tid is %lu\n",buffer,tid[i]); } while(1) { printf("我是主线程 pid:%d , ppid:%d , tid:\n",getpid(),getppid(),pthread_self()); sleep(2); } return 0; }
注意： 用pthread_self函数获得的线程ID与内核的LWP的值是不相等的，pthread_self函数获得的是用户级原生线程库的线程ID，而LWP是内核的轻量级进程ID，它们之间是一对一的关系。
pthread_ create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面说的线程ID
不是一回事。
前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要
一个数值来唯一表示该线程。
pthread_ create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，
属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。
线程库NPTL提供了pthread_ self函数，可以获得线程自身的ID：
pthread_t pthread_self(void);pthread_t 到底是什么类型呢？取决于实现。对于Linux目前实现的NPTL实现而言，pthread_t类型的线程ID，本质
就是一个进程地址空间上的一个地址。
为什么需要线程等待？
已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。
创建新的线程不会复用刚才退出线程的地址空间。
原型
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参数。
#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<unistd.h>
#include<pthread.h>
void*tineRou(void*arg)
{
char*msg=(char*)arg;
int count=0;
while(count<5)
{
printf("我是%s ...\n",msg);
sleep(1);
count++;
}
return NULL;
}
int main()
{
pthread_t tid[5];
for(int i=0;i<5;i++)
{
char* buffer=(char*)malloc(64);
sprintf(buffer," 线程:%d ",i);
pthread_create(&tid[i],NULL,tineRou,buffer);
printf("%s tid is %lu\n",buffer,tid[i]);
}
printf("我是主线程\n");
for(int i=0;i<5;i++)
{
pthread_join(tid[i],NULL);
printf("线程 %d...退出\n",i);
}
return 0;
}运行代码5s后，我们可以看到主线程等待成功
注意：pthread_join（）默认以阻塞的方式进行线程等待。
为什么线程退出时只能拿到线程的退出码？
如果我们等待的是一个进程，那么当这个进程退出时，我们可以通过wait函数或是waitpid函数的输出型参数status，获取到退出进程的退出码、退出信号以及core dump标志。
那为什么等待线程时我们只能拿到退出线程的退出码？难道线程不会出现异常吗？
线程在运行过程中当然也会出现异常，线程和进程一样，线程退出的情况也有三种：
代码运行完毕，结果正确。
代码运行完毕，结果不正确。
代码异常终止。
因此我们也需要考虑线程异常终止的情况，但是pthread_join函数无法获取到线程异常退出时的信息。因为线程是进程内的一个执行分支，如果进程中的某个线程崩溃了，那么整个进程也会因此而崩溃，此时我们根本没办法执行pthread_join函数，因为整个进程已经退出了。
例如，我们在线程的执行例程当中制造一个除零错误，当某一个线程执行到此处时就会崩溃，进而导致整个进程崩溃。
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
void* Routine(void* arg)
{
char* msg = (char*)arg;
int count = 0;
while (count < 5){
printf("I am %s...pid: %d, ppid: %d, tid: %lu\n", msg, getpid(), getppid(), pthread_self());
sleep(1);
count++;
int a = 1 / 0;
}
return (void*)2022;
}
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, buffer);
printf("%s tid is %lu\n", buffer, tid[i]);
}
printf("I am 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, exitcode: %d\n", i, tid[i], (int)ret);
}
return 0;
}
如果需要只终止某个线程而不是终止整个进程，可以有三种方法：
1、从线程函数return。
2、线程可以自己调用pthread_exit函数终止自己。
3、一个线程可以调用pthread_cancel函数终止同一进程中的另一个线程。
return退出
在线程中使用return代表当前线程退出，但是在main函数中使用return代表整个进程退出，也就是说只要主线程退出了那么整个进程就退出了，此时该进程曾经申请的资源就会被释放，而其他线程会因为没有了资源，自然而然的也退出了。
例如，在下面代码中，主线程创建五个新线程后立刻进行return，那么整个进程也就退出了。
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
void* Routine(void* arg)
{
char* msg = (char*)arg;
while (1){
printf("I am %s...pid: %d, ppid: %d, tid: %lu\n", msg, getpid(), getppid(), pthread_self());
sleep(1);
}
return (void*)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, buffer);
printf("%s tid is %lu\n", buffer, tid[i]);
}
printf("I am main thread...pid: %d, ppid: %d, tid: %lu\n", getpid(), getppid(), pthread_self());
return 0;
}
当程序执行时立即就退出了，线程并未执行Routine函数的打印功能，因为主线程的退出导致整个进程的退出。
线程退出函数———pthread_exit(void*retval)
参数说明：
retval:线程退出时的退出码。
说明一下：
该函数无返回值，跟进程一样，线程结束的时候无法返回它的调用者（自身）。
pthread_exit或者return返回的指针所指向的内存单元必须是全局的或者是用malloc分配的，不能在线程函数的栈上分配，因为当其他线程得到这个返回指针时，线程函数已经退出了。
例如，在下面代码中，我们使用pthread_exit函数终止线程，并将线程的退出码设置为10086。
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <sys/types.h>
void* Routine(void* arg)
{
char* msg = (char*)arg;
int count = 0;
while (count < 5){
printf("I am %s...pid: %d, ppid: %d, tid: %lu\n", msg, getpid(), getppid(), pthread_self());
sleep(1);
count++;
}
pthread_exit((void*)10086);
}
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, buffer);
printf("%s tid is %lu\n", buffer, tid[i]);
}
printf("I am 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, exitcode: %d\n", i, tid[i], ret);
}
注意：当线程调用exit()时进程也会被终止，任何一个线程调用exit()都会使进程提前终止。
原型
int pthread_calcel(pthread_t thread);功能：取消一个执行中的线程
参数
thread:线程ID
返回值：成功返回0；失败返回错误码
线程可以调用pthread_self()获取线程ID，再调用pthread_calcel()取消自己，取消成功退出码为-1。
例如以下程序：
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
#include<sys/types.h>
void* routine(void*arg)
{
char* msg=(char*)arg;
int count=0;
while(count<5)
{
printf("我是%s... pid:%d ,ppid:%d ,tid:%lu\n",msg,getpid(),getppid(),pthread_self());
sleep(1);
count++;
pthread_cancel(pthread_self());
}
pthread_exit ((void*)10086);
}
int main()
{
pthread_t tid[5];
for(int i=0;i<5;i++)
{
char*buffer=(char*)malloc(64);
sprintf(buffer,"线程：%d",i);
pthread_create(&tid[i],NULL,routine,buffer);
printf("%s tid 是 %lu\n",buffer,tid[i]);
}
printf("我是主线程... 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("线程：%d[%lu].....退出 退出码:%d\n",i,tid[i],ret);
}
return 0;
}
新线程也可以取消主线程。
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
#include<sys/types.h>
pthread_t main_pthread;
void* routine(void*arg)
{
char* msg=(char*)arg;
int count=0;
while(count<5)
{
printf("我是%s... pid:%d ,ppid:%d ,tid:%lu\n",msg,getpid(),getppid(),pthread_self());
sleep(1);
count++;
pthread_cancel(main_pthread);
}
pthread_exit ((void*)10086);
}
int main()
{
main_pthread=pthread_self();
pthread_t tid[5];
for(int i=0;i<5;i++)
{
char*buffer=(char*)malloc(64);
sprintf(buffer,"线程：%d",i);
pthread_create(&tid[i],NULL,routine,buffer);
printf("%s tid 是 %lu\n",buffer,tid[i]);
}
printf("我是主线程... 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("线程：%d[%lu].....退出 退出码:%d\n",i,tid[i],ret);
}
return 0;
}
注意：
1.当采用这种取消方式时，主线程和各个新线程之间的地位是对等的，取消一个线程，其他线程也是能够跑完的，只不过主线程不再执行后续代码了。
2.我们一般都是用主线程去控制新线程，这才符合我们对线程控制的基本逻辑，虽然实验表明新线程可以取消主线程，但是并不推荐该做法。
1、默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成内存泄漏。
2、但如果我们不关心线程的返回值，join也是一种负担，此时我们可以将该线程进行分离，后续当线程退出时就会自动释放线程资源。
3、一个线程如果被分离了，这个线程依旧要使用该进程的资源，依旧在该进程内运行，甚至这个线程崩溃了一定会影响其他线程，只不过这个线程退出时不再需要主线程去join了，当这个线程退出时系统会自动回收该线程所对应的资源。
4、可以是线程组内其他线程对目标线程进行分离，也可以是线程自己分离。
5、joinable和分离是冲突的，一个线程不能既是joinable又是分离的。
pthread_detach函数的函数原型如下：
int pthread_detach(pthread_t thread);
参数说明：
thread：被分离线程的ID。
返回值说明：
线程分离成功返回0，失败返回错误码。
例如，下面我们创建五个新线程后让这五个新线程将自己进行分离，那么此后主线程就不需要在对这五个新线程进行join了。
#include<stdio.h>
#include<stdlib.h>
#include<pthread.h>
#include<unistd.h>
#include<sys/types.h>
void* routine(void*arg)
{
pthread_detach(pthread_self());
char* msg=(char*)arg;
int count=0;
while(count<5)
{
printf("我是%s... pid:%d ,ppid:%d ,tid:%lu\n",msg,getpid(),getppid(),pthread_self());
sleep(1);
count++;
}
pthread_exit ((void*)10086);
}
int main()
{
pthread_t tid[5];
for(int i=0;i<5;i++)
{
char*buffer=(char*)malloc(64);
sprintf(buffer,"线程：%d",i);
pthread_create(&tid[i],NULL,routine,buffer);
printf("%s tid 是 %lu\n",buffer,tid[i]);
}
printf("我是主线程... pid:%d ,ppid:%d ,tid:%lu\n",getpid(),getppid(),pthread_self());
sleep(2);
return 0;
}