【线程】线程的控制

本文重点：理解线程控制的接口

前言

内核中是没有很明确线程的概念的，只有轻量级进程的概念，不会提供直接给我们线程的系统调用，而会给我们提供轻量级进程的系统调用。我们用户是需要线程的接口的，在应用层，人们封装了轻量级进程的系统调用，为用户直接提供线程的接口，这个封装的就是线程库pthread库，这个是第三方库，几乎所有的Linux系统都会自带这个库，当我们进行编译链接时，要指定这个库

线程的创建

函数pthread_create

参数:

thread:输出型参数，返回线程ID
attr:设置线程的属性，attr为nullptr表示使用默认属性
start_routine:是个函数指针，线程启动后要执行的函数
arg:传给线程启动函数的参数，线程被创建成功，新线程回调线程函数的时候需要参数，这个参数是给线程函数传递的

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

传统的一些函数是，成功返回0，失败返回-1，并且对全局变量errno赋值以指示错误。
pthreads函数出错时不会设置全局变量errno（而大部分其他线程函数会这样做）。而是将错误代码通过返回值返回
pthreads同样也提供了线程内的errno变量，以支持其它使用errno的代码。对于pthreads函数的错误，建议通过返回值判定，因为读取返回值要比读取线程内的errno变量的开销更小

线程的函数的参数和返回值，不仅仅可以用来进行传递一般参数，也可以传递对象

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<stdlib.h>using namespace std;void* threadroutine(void * arg)
{const char* name=(const char*)arg;while(true){cout<<name<<",pid: "<<getpid()<<endl;sleep(2);}
}int main()
{pthread_t tid;pthread_create(&tid,nullptr,threadroutine,(void*)"new thread");while(true){cout<<"main thread,pid: "<<getpid()<<endl;sleep(1);}return 0;
}

发现它们的pid是一样的

ps -aL 查看系统轻量级进程

LWP（light weight process）:线程ID，这个线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。

我们发现一个PID和LWP是一样的，那这个就是主线程，其他就是创建出来的线程

线程组内的第一个线程，在用户态被称为主线程(main thread),内核在创建第一个线程时，会将线程组的ID的值设置成第一个线程的线程ID，既主线程的进程描述符。所以线程组内存在一个线程ID等于进程ID，而该线程即为线程组的主线程

至于线程组其他线程的ID则有内核负责分配，其线程组ID总是和主线程的线程组ID一致，无论是主线程直接创建线程，还是创建出来的线程再次创建线程，都是这样

强调一点，线程和进程不一样，进程有父进程的概念，但在线程组里面，所有的线程都是对等关系

线程的终止

如果需要只终止某个线程而不终止整个进程,可以有三种方法:
1. 从线程函数return。这种方法对主线程不适用,从main函数return相当于调用exit。
2. 线程可以调用pthread_ exit终止自己。
3. 一个线程可以调用pthread_ cancel终止同一进程中的另一个线程。

注意：以前的进程终止函数exit是用来终止进程的

函数pthread_exit

参数和线程函数的返回值类型是一样的都是void*，这就和return终止线程差不多了

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

函数pthread_cancel

取消执行中的线程

线程的等待

在进程里有个进程等待，父进程等待子进程，是为了防止僵尸进程，回收子进程，防止内存泄漏

为什么需要线程等待？已经退出的线程，其空间没有被释放，仍然在进程的地址空间内。创建新的线程不会复用刚才退出线程的地址空间。那么线程中也要有线程等待，如果没有，那么也会有类似于僵尸的状态

函数pthread_join

函数的作用：等待指定线程，可以获取这个线程函数的返回值void*（终止状态）

参数：
thread:线程ID
value_ptr:它指向一个指针，就是指向线程创建时，调用的线程函数的返回值void*
返回值：成功返回0；失败返回错误码

调用该函数的线程将阻塞等待,直到id为thread的线程终止。thread线程以不同的方法终止,通过pthread_join得到的终止状态是不同的，总结如下:
1. 如果thread线程通过return返回,value_ ptr所指向的单元里存放的是thread线程函数的返回值。
2. 如果thread线程被别的线程调用pthread_ cancel异常终掉,value_ ptr所指向的单元里存放的是常数PTHREAD_CANCELED（一个宏常数，就是-1）。
3. 如果thread线程是自己调用pthread_exit终止的,value_ptr所指向的单元存放的是传pthread_exit的参数。
4. 如果对thread线程的终止状态不感兴趣,可以传nullptr给value_ ptr参数。

#include<iostream>
#include<pthread.h>
#include<unistd.h>
#include<stdlib.h>using namespace std;void* threadroutine(void * arg)
{const char* name=(const char*)arg;int cnt=5;while(true){cout<<name<<",pid: "<<getpid()<<endl;sleep(1);cnt--;if(cnt==0) break;}return (void*)1;//我的当前平台，地址是64位，8字节，而int是4字节，不进行强转会导致混乱
}int main()
{pthread_t tid;pthread_create(&tid,nullptr,threadroutine,(void*)"new thread");void * retval;pthread_join(tid,&retval);// main thread等待的时候，默认是阻塞等待的！cout << "main thread quit ..., ret: " << (long long int)retval << endl;return 0;
}

为什么我们在这里join的时候不考虑异常呢？？因为做不到，线程异常了整个进程都会挂掉。线程的健壮性低

线程的分离

上面的线程等待，只能阻塞等待，那如果不想阻塞怎么办，并且不关心线程的返回值，那就让线程分离，线程分离之后，主线程就不管了，主线程就干自己的事了，自己的资源自己释放回收了，虽然线程分离了，但是还是属于这个进程的

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

joinable和分离是冲突的，一个线程不能既是joinable又是分离的，也就是说，线程分离了，主线程就不用等待回收线程了

#include<iostream>
#include<cstring>
#include<unistd.h>
#include<pthread.h>
void* PthreadRoutine(void* args)
{int i=0;pthread_detach(pthread_self());while(i<3){cout<<"child thread ,pid: "<<getpid()<<endl;i++;sleep(1);}return nullptr;
}
int main()
{pthread_t tid;pthread_create(&tid,nullptr,PthreadRoutine,nullptr);sleep(1);//确保分离成功int n=pthread_join(tid,nullptr);printf("n = %d, who = 0x%x, why: %s\n", n, tid, strerror(n));return 0;}

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

pthread_ create函数会产生一个线程ID，存放在第一个参数指向的地址中。该线程ID和前面说的线程ID不是一回事。前面讲的线程ID属于进程调度的范畴。因为线程是轻量级进程，是操作系统调度器的最小单位，所以需要一个数值来唯一表示该线程。
pthread_ create函数第一个参数指向一个虚拟内存单元，该内存单元的地址即为新创建线程的线程ID，属于NPTL线程库的范畴。线程库的后续操作，就是根据该线程ID来操作线程的。
线程库NPTL提供了pthread_ self函数，可以获得线程自身的ID

函数pthread_self

函数clone

这个函数clone是系统调用，用来创建轻量级进程的，前言说的pthread库的底层就是用这个函数封装的

使用线程库，是要加载到内存的，它是动态库，所以会在地址空间的共享区。

线程的概念是库给我们维护的，线程库注定要维护多个线程，线程库要管理这些线程，先描述再组织，每个线程都会有一个库级别的结构体tcb，这个结构体的起始地址就是线程的id

除了主线程外，所有的其他线程的独立栈，都在共享区，具体来讲，是在pthread库中，tid指向用户的tcb。全局变量和堆区都是线程共享的，栈不是，每个线程都有自己的独立栈

目前，我们的原生线程，pthread库，原生线程库，C++11 语言本身也已经支持多线程了 vs 原生线程库。其实C++的多线程底层封装的就是Linux系统下的原生线程库，为什么C++移值性高，就是因为C++的代码在不同平台上都可以跑，在Linux下跑多线程底层就是Linux的原生线程库，在Windows跑，底层就是Windows的原生线程库，C++语音在底层设计时，不同的系统有不同的设计，但是在上层看来都一样

#include <iostream>
#include <thread>using namespace std;void threadrun()
{while(true){cout << "I am a new thead for C++" << endl;sleep(1);}
}int main()
{thread t1(threadrun);t1.join();return 0;
}

多线程的创建

1.创建多线程

#include<iostream>
#include<string>
#include<vector>
#include<unistd.h>
#include<pthread.h>using namespace std;#define NUM 4class ThreadData
{
public:ThreadData(int number){_threadname="thread-"+to_string(number);}
public:string _threadname;
};string toHex(pthread_t tid)
{char buf[128];snprintf(buf,sizeof(buf),"0x%x",tid);return buf;}
void* ThreadRoutine(void* args)
{ThreadData* td=static_cast<ThreadData*>(args);string tid=toHex(pthread_self());pid_t pid=getpid();int i=0;while(i<3){cout<<td->_threadname<<" pid: "<<pid<<" tid: "<<tid<<endl;i++;sleep(1);}delete td;return nullptr;
}
int main()
{vector<pthread_t> tids;//创建多线程for(int i=1;i<=NUM;i++){pthread_t tid;ThreadData* td=new ThreadData(i);pthread_create(&tid,nullptr,ThreadRoutine,td);tids.push_back(tid);sleep(1);}//等待多线程for(auto tid:tids){pthread_join(tid,nullptr);}cout<<"main thread wait success"<<endl;return 0;
}

上面代码在主线程开辟的堆空间传递给了子线程，子线程还可以利用，说明堆空间是被所有线程共享的

2.验证全局变量共享

在上面代码上加个全局变量g_val，在子线程打印他的地址

#include<iostream>
#include<string>
#include<vector>
#include<unistd.h>
#include<pthread.h>using namespace std;#define NUM 4
int g_val=0;//定义一个全局class ThreadData
{
public:ThreadData(int number){_threadname="thread-"+to_string(number);}
public:string _threadname;
};string toHex(pthread_t tid)
{char buf[128];snprintf(buf,sizeof(buf),"0x%x",tid);return buf;}
void* ThreadRoutine(void* args)
{ThreadData* td=static_cast<ThreadData*>(args);string tid=toHex(pthread_self());pid_t pid=getpid();int i=0;while(i<3){cout<<td->_threadname<<" pid: "<<pid<<" tid: "<<tid<<",g_val: "<<g_val<<",&g_val: "<<&g_val<<endl;i++;sleep(1);}delete td;return nullptr;
}
int main()
{vector<pthread_t> tids;//创建多线程for(int i=1;i<=NUM;i++){pthread_t tid;ThreadData* td=new ThreadData(i);pthread_create(&tid,nullptr,ThreadRoutine,td);tids.push_back(tid);sleep(1);}//等待多线程for(auto tid:tids){pthread_join(tid,nullptr);}cout<<"main thread wait success"<<endl;return 0;
}

发现这个全局变量的地址都是一样的，说明全局变量被所有线程共享

3.线程的局部存储

如果线程不想共享全局变量，想要自己私有的全局变量，那么在全局变量加__thread修饰（两个下划线），这个是个编译选项，只能用来定义内置类型，不能修饰自定义类型，那么这个全局变量就不在全局区了，就在线程的栈结构的局部存储中，这个是线程级别的全局变量，也就是在某个线程里面时全局的

地址不一样，并且这个地址挺大的，说明在中间的堆栈之间

4.验证线程具有独立栈结构

在每个线程里面加个变量test_i，打印他的地址

#include<iostream>
#include<string>
#include<vector>
#include<unistd.h>
#include<pthread.h>using namespace std;#define NUM 4class ThreadData
{
public:ThreadData(int number){_threadname="thread-"+to_string(number);}
public:string _threadname;
};string toHex(pthread_t tid)
{char buf[128];snprintf(buf,sizeof(buf),"0x%x",tid);return buf;}
void* ThreadRoutine(void* args)
{ThreadData* td=static_cast<ThreadData*>(args);string tid=toHex(pthread_self());pid_t pid=getpid();int i=0;int test_i=0;while(i<3){cout<<td->_threadname<<" pid: "<<pid<<" tid: "<<tid<<",test_i: "<<test_i<<",&test_i: "<<&test_i<<endl;;i++;sleep(1);}delete td;return nullptr;
}
int main()
{vector<pthread_t> tids;//创建多线程for(int i=1;i<=NUM;i++){pthread_t tid;ThreadData* td=new ThreadData(i);pthread_create(&tid,nullptr,ThreadRoutine,td);tids.push_back(tid);sleep(1);}//等待多线程for(auto tid:tids){pthread_join(tid,nullptr);}cout<<"main thread wait success"<<endl;return 0;
}