Linux--线程的分离、线程库的地址关系的理解、线程的简单封装（二）

线程系列：
线程的认识：讲解线程的概念和线程的基本控制

线程的分离

线程分离是指将一个线程从主线程中分离出来，使其能够独立运行。当一个线程被设置为分离状态时，它结束时系统会自动回收其资源，而不需要其他线程使用pthread_join()函数来等待其结束并手动回收资源。

设置线程分离的方法：
使用

pthread_detach

()函数：在线程创建后，可以通过调用

pthread_detach

()函数来将线程设置为分离状态。这个函数是非阻塞式的，即调用后不会阻塞当前线程的执行。
在创建线程时设置分离属性：另一种方法是在创建线程时，通过

pthread_create

()函数的第二个参数（线程属性）来设置线程为分离状态。这种方法在创建线程时即指定了其分离属性，效率相对较高。

void*threadrun(void* args){
    string name =static_cast<constchar*>(args);while(true){sleep(1);
        cout<<"this is new thread:"<<name<<endl;}}intmain(){
    pthread_t tid;pthread_create(&tid,nullptr, threadrun,(void*)"thread 1");
    cout <<"main thread wait block"<< std::endl;pthread_join(tid,nullptr);
    cout <<"main thread wait return"<<endl;}

使用分离函数后：

再加个有限时间的循环看看：

对线程分离理解：虽然新线程与主线程已经分离了，但它们仍然是同一进程中的执行流，如果程序使用时出现异常时（新线程或者主线程），那么两个程序都会终止；或者说主线程结束了，实际上就代表进程结束了;所以线程的分离仍然是在进程中进行的，受进程的影响；

何时使用：当线程完成任务后不需要与其结果交付时；当线程在后台运行且不需要与主线程进行同步进行时；

注意：分离线程无法重新连接！而可连接线程可以分离，当只有在尚未开始运行之前。

理解线程库的地址关系

线程栈

线程栈是与线程紧密相关的内存区域，用于存储线程的局部变量、函数调用的返回地址以及线程的执行上下文等信息。每个线程都有自己独立的栈空间，这保证了线程之间的数据是隔离的，从而避免数据竞争和线程安全问题。

#include<iostream>usingnamespace std;#include<pthread.h>#include<unistd.h>void*threadrun1(void*args){  
    std::string name =static_cast<constchar*>(args);int g_val=100;while(true){sleep(1);printf("%s, g_val: %lu, &g_val: %p\n", name.c_str(), g_val--,&g_val);}returnnullptr;}void*threadrun2(void*args){
    std::string name =static_cast<constchar*>(args);int g_val=100;while(true){printf("%s, g_val: %lu, &g_val: %p\n", name.c_str(), g_val--,&g_val);sleep(1);}returnnullptr;}intmain(){
    pthread_t tid1;
    pthread_t tid2;pthread_create(&tid1,nullptr, threadrun1,(void*)"thread 1");pthread_create(&tid2,nullptr, threadrun2,(void*)"thread 2");pthread_join(tid1,nullptr);pthread_join(tid2,nullptr);}

通过两个新线程都创建一个局部变量（变量名相同），比较它们的地址；

可以看到g_val在各自线程是不一样的，地址也是不同的;

线程局部存储（TLS）

线程局部存储（TLS）是一种机制，允许每个线程拥有自己的私有数据副本，即使不同线程执行相同的代码，TLS变量与常规全局变量是不同的，因为每个线程堆TLS变量的访问都是独立的。

一般适用于：

• 线程特定数据：当某些数据只对特定线程有意义，并且需要在线程内保持状态时，可以使用线程局部存储。
• 全局状态隔离：通过将全局状态分离为每个线程的私有副本，可以提高并发性能，避免线程间的数据竞争。
• 线程上下文保存：线程局部存储也可用于保存当前执行线程的上下文信息，如用户身份验证信息、数据库连接等。

注意：

线程局部存储变量通常只能用于具有静态或线程存储期的变量，不能用于自动或动态分配的变量。使用线程局部存储时需要谨慎管理内存，避免内存泄漏或无效访问等问题。

线程的封装

线程的封装通常指的是将线程的创建、执行、同步、资源管理等逻辑封装到一个类或对象中，以便更好地组织代码，提高代码的可读性和可维护性。

封装线程可以隐藏线程的复杂性，使得其他部分的代码可以更加简洁地与线程进行交互。

下面看具体代码：

Thread.hpp：对线程的封装

#ifndef__THREAD_HPP__#define__THREAD_HPP__#include<iostream>#include<string>#include<pthread.h>#include<functional>#include<unistd.h>usingnamespace std;namespace ThreadMdule
{//通过模板类可调用一切任何对象template<typenameT>using func_t = std::function<void(T&)>;template<typenameT>classThread{public:voidExcute(){_func(_data);}Thread(func_t<T> func, T data,const std::string &name="none-name"):_func(func),_data(data),_threadname(name),_stop(true){}staticvoid*threadroutine(void* args){
            Thread<T>* self=static_cast<Thread<T>*>(args);
            self->Excute();returnnullptr;}boolstart(){int n=pthread_create(&_tid,nullptr,threadroutine,this);if(!n){
                _stop =false;returntrue;}else{returnfalse;}}voidDetach(){if(!_stop){pthread_detach(_tid);}}voidJoin(){if(!_stop){pthread_join(_tid,nullptr);}}
        string name(){return _threadname;}voidStop(){
            _stop =true;}~Thread(){}private:
        pthread_t _tid;
        std::string _threadname;
        T _data;  
        func_t<T> _func;bool _stop;};}#endif

线程类中包括了：线程名，数据，调用函数指针等；
通过start()函数来创建新线程：用到了函数threadroutinue，在函数中将函数成员_func（也就是具体函数的指针）使用了起来，就表示新线程的创建使用；

主函数的调用：

voidprint(int&cnt){while(cnt){
        std::cout <<"hello I am myself thread, cnt: "<< cnt--<< std::endl;sleep(1);}}constint num=3;intmain(){
    vector<Thread<int>> threads;//创建新线程for(int i=0;i<num;i++){
        string name="thread"+to_string(i +1);
        threads.emplace_back(print,3,name);}//启动进程for(auto& thread:threads){
        thread.start();}//等待进程结束for(auto& thread:threads){
        thread.Join();
        cout<<"wait thread done,thread is: "<<thread.name()<<endl;}return0;}

这样就是对线程的简单封装；

通过封装线程，我们可以更好地控制线程的创建、执行和销毁过程，同时使得代码更加清晰和易于维护。

此外，封装还可以帮助我们添加额外的功能，比如线程池的集成、异常处理、线程同步等。