【Linux】第四十二站：线程局部存储与线程分离

2024-03-11 16:36
文章标签 分离 linux 线程 存储 局部 第四十二

本文主要是介绍【Linux】第四十二站：线程局部存储与线程分离，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

一、线程的局部存储

1.实现多线程

如果我们想创建多线程，我们可以用下面的代码类似去实现

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
using namespace std;
#define NUM 10struct threadData
{string threadname;
};
string toHex(pthread_t tid)
{char buffer[128];snprintf(buffer, sizeof(buffer), "0x%x", tid);return buffer;
}
void* threadRoutine(void* args)
{threadData *td = static_cast<threadData*>(args);int i = 0;while(i < 10){cout << "pid: " << getpid() << ", tid : " << toHex(pthread_self()) << ", threadname : " << td->threadname << endl;sleep(1);i++;}delete td;return nullptr;
}void InitThreadData(threadData* td, int number)
{td->threadname = "thread-" + to_string(number); 
}int main()
{vector<pthread_t> tids;for(int i = 0; i < NUM; i++){//注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次//td也要随之销毁掉。这里传入的全部都是野指针了。// threadData td;// td.threadname = "";// td.tid = "";pthread_t tid;threadData *td = new threadData;InitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);sleep(1);}for(int i = 0; i < tids.size(); i++){pthread_join(tids[i], nullptr);}return 0;
}

运行结果如下图所示

image-20240229203441892

在这里我们就发现了一个问题：

所有的线程，执行的都是这个函数

一旦一个线程修改了数据，其他线程看到这个数据都会被修改

2.线程有独立的栈结构

当代码如下的时候

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
using namespace std;
#define NUM 3struct threadData
{string threadname;
};
string toHex(pthread_t tid)
{char buffer[128];snprintf(buffer, sizeof(buffer), "0x%x", tid);return buffer;
}
void* threadRoutine(void* args)
{int test_i = 0;threadData *td = static_cast<threadData*>(args);int i = 0;while(i < 10){cout << "pid: " << getpid() << ", tid : " << toHex(pthread_self()) << ", threadname : " << td->threadname << ", test_i: " << test_i << ", &test_i: " << toHex((pthread_t)&test_i) << endl;sleep(1);i++;test_i++;}delete td;return nullptr;
}void InitThreadData(threadData* td, int number)
{td->threadname = "thread-" + to_string(number); 
}int main()
{vector<pthread_t> tids;for(int i = 0; i < NUM; i++){//注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次//td也要随之销毁掉。这里传入的全部都是野指针了。// threadData td;// td.threadname = "";// td.tid = "";pthread_t tid;threadData *td = new threadData;InitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);sleep(1);}for(int i = 0; i < tids.size(); i++){pthread_join(tids[i], nullptr);}return 0;
}

运行结果为：

image-20240229204957681

我们可以看到每一个线程的test_i都会独立的增长，并且每个test_i的地址都不一样

这是因为每一个线程都会有自己独立的栈结构。

3.线程之间没有秘密

那么如果我们主线程就想要访问上面线程1的变量，我们可以做到吗？当然可以做到，因为它也在同一个地址空间中。

就比如下面的代码就可以实现主线程访问线程2的变量

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
using namespace std;
#define NUM 3int *p = NULL;struct threadData
{string threadname;
};
string toHex(pthread_t tid)
{char buffer[128];snprintf(buffer, sizeof(buffer), "0x%x", tid);return buffer;
}
void* threadRoutine(void* args)
{int test_i = 0;threadData *td = static_cast<threadData*>(args);if(td->threadname == "thread-2"){p = &test_i;}int i = 0;while(i < 10){cout << "pid: " << getpid() << ", tid : " << toHex(pthread_self()) << ", threadname : " << td->threadname << ", test_i: " << test_i << ", &test_i: " << &test_i << endl;sleep(1);i++;test_i++;}delete td;return nullptr;
}void InitThreadData(threadData* td, int number)
{td->threadname = "thread-" + to_string(number); 
}int main()
{vector<pthread_t> tids;for(int i = 0; i < NUM; i++){//注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次//td也要随之销毁掉。这里传入的全部都是野指针了。// threadData td;// td.threadname = "";// td.tid = "";pthread_t tid;threadData *td = new threadData;InitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);}sleep(1); //确保复制成功cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;   for(int i = 0; i < tids.size(); i++){pthread_join(tids[i], nullptr);}return 0;
}

运行结果为：

image-20240229211018969

所以其实在线程和线程当中没有秘密，只不过我们要求每一个线程有自己独立的栈，但是他们还在通一个地址空间中，线程的栈上的数据，也是可以被其他线程看到并且访问的。如果我们一个线程想要访问另一个线程的值，当然可以访问，只不过我们平时禁止这样做。

4.线程的局部存储

如下所示，代码是多线程访问同一个变量的代码

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
using namespace std;
#define NUM 3//int *p = NULL;int g_val = 100;struct threadData
{string threadname;
};
string toHex(pthread_t tid)
{char buffer[128];snprintf(buffer, sizeof(buffer), "0x%x", tid);return buffer;
}
void* threadRoutine(void* args)
{//int test_i = 0;threadData *td = static_cast<threadData*>(args);// if(td->threadname == "thread-2")// {//     p = &test_i;// }int i = 0;while(i < 10){cout << "pid: " << getpid() << ", tid : " << toHex(pthread_self()) << ", threadname : " << td->threadname << ", g_val: " << g_val << ", &g_val: " << &g_val << endl; // << ", test_i: " << test_i << ", &test_i: " << &test_i << endl;sleep(1);i++;g_val++;//  test_i++;}delete td;return nullptr;
}void InitThreadData(threadData* td, int number)
{td->threadname = "thread-" + to_string(number); 
}int main()
{vector<pthread_t> tids;for(int i = 0; i < NUM; i++){//注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次//td也要随之销毁掉。这里传入的全部都是野指针了。// threadData td;// td.threadname = "";// td.tid = "";pthread_t tid;threadData *td = new threadData;InitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);}sleep(1); //确保复制成功// cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;   for(int i = 0; i < tids.size(); i++){pthread_join(tids[i], nullptr);}return 0;
}

运行结果为：

image-20240229212555074

所以全局变量是被所有的线程看到并同时访问的。

这个g_val就是共享资源。

但是如果一个线程想要一个私有的全局变量呢？

所以我们可以下面这样做：在全局变量之前加上**__thread**

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
using namespace std;
#define NUM 3//int *p = NULL;__thread int g_val = 100;struct threadData
{string threadname;
};
string toHex(pthread_t tid)
{char buffer[128];snprintf(buffer, sizeof(buffer), "0x%x", tid);return buffer;
}
void* threadRoutine(void* args)
{//int test_i = 0;threadData *td = static_cast<threadData*>(args);// if(td->threadname == "thread-2")// {//     p = &test_i;// }int i = 0;while(i < 10){cout << "pid: " << getpid() << ", tid : " << toHex(pthread_self()) << ", threadname : " << td->threadname << ", g_val: " << g_val << ", &g_val: " << &g_val << endl; // << ", test_i: " << test_i << ", &test_i: " << &test_i << endl;sleep(1);i++;g_val++;//  test_i++;}delete td;return nullptr;
}void InitThreadData(threadData* td, int number)
{td->threadname = "thread-" + to_string(number); 
}int main()
{vector<pthread_t> tids;for(int i = 0; i < NUM; i++){//注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次//td也要随之销毁掉。这里传入的全部都是野指针了。// threadData td;// td.threadname = "";// td.tid = "";pthread_t tid;threadData *td = new threadData;InitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);}sleep(1); //确保复制成功// cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;   for(int i = 0; i < tids.size(); i++){pthread_join(tids[i], nullptr);}return 0;
}

运行结果为

image-20240229213247688

这样的对一个变量加上__thread的，我们将这个称作线程的局部存储

而我们前面正好就说了:在线程的tcb中，就有一个线程的局部存储

image-20240229213409277

所以我们可以明显看到，这个变量应该就在动态库中存储着。

这个__thread其实就是编译器编译时候的一个默认选项。

我们也可以直接从前面的两个图中的地址可以看出，没加这个选项的地址比较小（在静态区），加上这个选项地址比较大（处于堆栈之间的共享区）。

注意：这个__thread选项只能定义内置类型，不能用来修饰自定义类型

有了这个选项，对于某些只属于这个线程的变量，我们可以使用这个__thread来进行修饰，让它变为局部存储。这样的好处是可以不用频繁的去调用某些系统调用接口。

image-20240229214128231

这样就实现了线程级别的全局变量，和其他线程互不干扰。

二、分离线程

  • 默认情况下，新创建的线程是joinable的，线程退出后，需要对其进行pthread_join操作，否则无法释放资源，从而造成系统泄漏。
  • 如果不关心线程的返回值，join是一种负担，这个时候，我们可以告诉系统，当线程退出时，自动释放线程资源
#include <pthread.h>
int pthread_detach(pthread_t thread);
//Compile and link with -pthread.

这个分离接口既可以由主线程来做，也可以由其他新线程来做

我们可以先在join前先分离一下，看看是什么结果

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
#include <cstring>
#include <cstdio>
using namespace std;
#define NUM 3//int *p = NULL;__thread int g_val = 100;
__thread int number = 0;
struct threadData
{string threadname;
};
string toHex(pthread_t tid)
{char buffer[128];snprintf(buffer, sizeof(buffer), "0x%x", tid);return buffer;
}
void* threadRoutine(void* args)
{//int test_i = 0;threadData *td = static_cast<threadData*>(args);number = pthread_self();// if(td->threadname == "thread-2")// {//     p = &test_i;// }int i = 0;while(i < 10){//cout << "number: " << number << ", pid: " << getpid() << endl;printf("number: 0x%x, pid: %d\n", number, getpid());//cout << "pid: " << getpid() << ", tid : " << toHex(number) << ", threadname : " << td->threadname << ", g_val: " << g_val << ", &g_val: " << &g_val << endl;         // << ", test_i: " << test_i << ", &test_i: " << &test_i << endl;sleep(1);i++;g_val++;//  test_i++;}delete td;return nullptr;
}void InitThreadData(threadData* td, int number)
{td->threadname = "thread-" + to_string(number); 
}int main()
{vector<pthread_t> tids;for(int i = 0; i < NUM; i++){//注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次//td也要随之销毁掉。这里传入的全部都是野指针了。// threadData td;// td.threadname = "";// td.tid = "";pthread_t tid;threadData *td = new threadData;InitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);}usleep(100000); //确保复制成功// cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;   for(auto i : tids){pthread_detach(i);}for(int i = 0; i < tids.size(); i++){int n = pthread_join(tids[i], nullptr);printf("n = %d, who = 0x%x, why: %s\n", n , tids[i], strerror(n));}return 0;
}

运行结果为：

image-20240301162551454

可见我们将线程给detach以后，再去join就不会成功了

我们也可以线程自己把自己分离掉

#include <iostream>
#include <pthread.h>
#include <string>
#include <cstdlib>
#include <unistd.h>
#include <thread>
#include <vector>
#include <cstring>
#include <cstdio>
using namespace std;
#define NUM 3//int *p = NULL;__thread int g_val = 100;
__thread int number = 0;
struct threadData
{string threadname;
};
string toHex(pthread_t tid)
{char buffer[128];snprintf(buffer, sizeof(buffer), "0x%x", tid);return buffer;
}
void* threadRoutine(void* args)
{pthread_detach(pthread_self());//int test_i = 0;threadData *td = static_cast<threadData*>(args);number = pthread_self();// if(td->threadname == "thread-2")// {//     p = &test_i;// }int i = 0;while(i < 10){//cout << "number: " << number << ", pid: " << getpid() << endl;printf("number: 0x%x, pid: %d\n", number, getpid());//cout << "pid: " << getpid() << ", tid : " << toHex(number) << ", threadname : " << td->threadname << ", g_val: " << g_val << ", &g_val: " << &g_val << endl;         // << ", test_i: " << test_i << ", &test_i: " << &test_i << endl;sleep(1);i++;g_val++;//  test_i++;}delete td;return nullptr;
}void InitThreadData(threadData* td, int number)
{td->threadname = "thread-" + to_string(number); 
}int main()
{vector<pthread_t> tids;for(int i = 0; i < NUM; i++){//注意这种方式不可以，因为都在主线程的栈中定义的变量。一旦for循环每循环一次//td也要随之销毁掉。这里传入的全部都是野指针了。// threadData td;// td.threadname = "";// td.tid = "";pthread_t tid;threadData *td = new threadData;InitThreadData(td, i);pthread_create(&tid, nullptr, threadRoutine, td);tids.push_back(tid);}usleep(100000); //确保复制成功// cout << "main thread get a thread local value, val: " << *p << ", &val: " << p << endl;   // for(auto i : tids)// {//     pthread_detach(i);// }for(int i = 0; i < tids.size(); i++) {int n = pthread_join(tids[i], nullptr);printf("n = %d, who = 0x%x, why: %s\n", n , tids[i], strerror(n));}return 0;
}

运行结果也是一样的

image-20240301162921478

当线程内部的函数结束之后，会自动释放掉线程的资源

我们上面两个例子会发现一个问题，那就是分离线程应该会在线程跑完之后进行回收的。但是为什么还没有跑完就被回收了呢。这是因为我们在下面就有一个join，去等待了线程了。它在等待的发现已经被分离了。就不是阻塞式的等了，立马就出错返回了。出错返回后，这个for循环立刻就跑完了，跑完之后，主线成结束了，所以进程就结束了。所以虽然上面的线程还没有跑完，但是进程已经结束了，这些资源也就被释放了。

这里也告诉我们，即便我们的主线程将线程分离了，不用等待了，但是我们还是要自己去确保主线程是最后退出的，否则会出现一些问题。

所以线程是否被分离其实就是一个属性状态。它一定是要被存储的。所以线程分离其实就是将这个属性进行了修改

这篇关于【Linux】第四十二站：线程局部存储与线程分离的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/798389。

相关文章

Linux线程同步/互斥过程详解

Linux线程同步/互斥过程详解

《Linux线程同步/互斥过程详解》文章讲解多线程并发访问导致竞态条件,需通过互斥锁、原子操作和条件变量实现线程安全与同步,分析死锁条件及避免方法,并介绍RAII封装技术提升资源管理效率... 目录01. 资源共享问题1.1 多线程并发访问1.2 临界区与临界资源1.3 锁的引入02. 多线程案例2.1 为
阅读更多...
Oracle数据库定时备份脚本方式(Linux)

Oracle数据库定时备份脚本方式(Linux)

《Oracle数据库定时备份脚本方式(Linux)》文章介绍Oracle数据库自动备份方案,包含主机备份传输与备机解压导入流程,强调需提前全量删除原库数据避免报错,并需配置无密传输、定时任务及验证脚本... 目录说明主机脚本备机上自动导库脚本整个自动备份oracle数据库的过程（建议全程用root用户）总结
阅读更多...
Linux如何查看文件权限的命令

Linux如何查看文件权限的命令

《Linux如何查看文件权限的命令》Linux中使用ls-R命令递归查看指定目录及子目录下所有文件和文件夹的权限信息,以列表形式展示权限位、所有者、组等详细内容... 目录linux China编程查看文件权限命令输出结果示例这里是查看tomcat文件夹总结Linux 查看文件权限命令ls -l 文件或文件夹
阅读更多...
idea的终端(Terminal)cmd的命令换成linux的命令详解

idea的终端(Terminal)cmd的命令换成linux的命令详解

《idea的终端(Terminal)cmd的命令换成linux的命令详解》本文介绍IDEA配置Git的步骤：安装Git、修改终端设置并重启IDEA,强调顺序,作为个人经验分享,希望提供参考并支持脚本之... 目录一编程、设置前二、前置条件三、android设置四、设置后总结一、php设置前二、前置条件
阅读更多...
Linux系统中查询JDK安装目录的几种常用方法

Linux系统中查询JDK安装目录的几种常用方法

《Linux系统中查询JDK安装目录的几种常用方法》：本文主要介绍Linux系统中查询JDK安装目录的几种常用方法,方法分别是通过update-alternatives、Java命令、环境变量及目... 目录方法 1：通过update-alternatives查询（推荐）方法 2：检查所有已安装的 JDK方
阅读更多...
Linux系统之lvcreate命令使用解读

Linux系统之lvcreate命令使用解读

《Linux系统之lvcreate命令使用解读》lvcreate是LVM中创建逻辑卷的核心命令,支持线性、条带化、RAID、镜像、快照、瘦池和缓存池等多种类型,实现灵活存储资源管理,需注意空间分配、R... 目录lvcreate命令详解一、命令概述二、语法格式三、核心功能四、选项详解五、使用示例1. 创建逻
阅读更多...
Linux下在线安装启动VNC教程

Linux下在线安装启动VNC教程

《Linux下在线安装启动VNC教程》本文指导在CentOS7上在线安装VNC,包含安装、配置密码、启动/停止、清理重启步骤及注意事项,强调需安装VNC桌面以避免黑屏,并解决端口冲突和目录权限问题... 目录描述安装VNC安装 VNC 桌面可能遇到的问题总结描js述linux中的VNC就类似于Window
阅读更多...
linux下shell脚本启动jar包实现过程

linux下shell脚本启动jar包实现过程

《linux下shell脚本启动jar包实现过程》确保APP_NAME和LOG_FILE位于目录内,首次启动前需手动创建log文件夹,否则报错,此为个人经验,供参考,欢迎支持脚本之家... 目录linux下shell脚本启动jar包样例1样例2总结linux下shell脚本启动jar包样例1#!/bin
阅读更多...
在MySQL中实现冷热数据分离的方法及使用场景底层原理解析

在MySQL中实现冷热数据分离的方法及使用场景底层原理解析

《在MySQL中实现冷热数据分离的方法及使用场景底层原理解析》MySQL冷热数据分离通过分表/分区策略、数据归档和索引优化,将频繁访问的热数据与冷数据分开存储,提升查询效率并降低存储成本,适用于高并发... 目录实现冷热数据分离1. 分表策略2. 使用分区表3. 数据归档与迁移在mysql中实现冷热数据分
阅读更多...
Linux之platform平台设备驱动详解

Linux之platform平台设备驱动详解

《Linux之platform平台设备驱动详解》Linux设备驱动模型中,Platform总线作为虚拟总线统一管理无物理总线依赖的嵌入式设备,通过platform_driver和platform_de... 目录platform驱动注册platform设备注册设备树Platform驱动和设备的关系总结在 l
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2