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

2024-03-11 16:36

本文主要是介绍【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

相关文章

C语言中的浮点数存储详解

《C语言中的浮点数存储详解》:本文主要介绍C语言中的浮点数存储详解,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录1、首先明确一个概念2、接下来,讲解C语言中浮点型数存储的规则2.1、可以将上述公式分为两部分来看2.2、问:十进制小数0.5该如何存储?2.3 浮点

Linux下修改hostname的三种实现方式

《Linux下修改hostname的三种实现方式》:本文主要介绍Linux下修改hostname的三种实现方式,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录linux下修改ho编程stname三种方式方法1:修改配置文件方法2:hFvEWEostnamectl命

Linux虚拟机不显示IP地址的解决方法(亲测有效)

《Linux虚拟机不显示IP地址的解决方法(亲测有效)》本文主要介绍了通过VMware新装的Linux系统没有IP地址的解决方法,主要步骤包括:关闭虚拟机、打开VM虚拟网络编辑器、还原VMnet8或修... 目录前言步骤0.问题情况1.关闭虚拟机2.China编程打开VM虚拟网络编辑器3.1 方法一:点击还原VM

Java捕获ThreadPoolExecutor内部线程异常的四种方法

《Java捕获ThreadPoolExecutor内部线程异常的四种方法》这篇文章主要为大家详细介绍了Java捕获ThreadPoolExecutor内部线程异常的四种方法,文中的示例代码讲解详细,感... 目录方案 1方案 2方案 3方案 4结论方案 1使用 execute + try-catch 记录

Linux搭建Mysql主从同步的教程

《Linux搭建Mysql主从同步的教程》:本文主要介绍Linux搭建Mysql主从同步的教程,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教... 目录linux搭建mysql主从同步1.启动mysql服务2.修改Mysql主库配置文件/etc/my.cnf3.重启主库my

MySQL常见的存储引擎和区别说明

《MySQL常见的存储引擎和区别说明》MySQL支持多种存储引擎,如InnoDB、MyISAM、MEMORY、Archive、CSV和Blackhole,每种引擎有其特点和适用场景,选择存储引擎时需根... 目录mysql常见的存储引擎和区别说明1. InnoDB2. MyISAM3. MEMORY4. A

Linux系统之authconfig命令的使用解读

《Linux系统之authconfig命令的使用解读》authconfig是一个用于配置Linux系统身份验证和账户管理设置的命令行工具,主要用于RedHat系列的Linux发行版,它提供了一系列选项... 目录linux authconfig命令的使用基本语法常用选项示例总结Linux authconfi

jdk21下载、安装详细教程(Windows、Linux、macOS)

《jdk21下载、安装详细教程(Windows、Linux、macOS)》本文介绍了OpenJDK21的下载地址和安装步骤,包括Windows、Linux和macOS平台,下载后解压并设置环境变量,最... 目录1、官网2、下载openjdk3、安装4、验证1、官网官网地址:OpenJDK下载地址:Ar

linux本机进程间通信之UDS详解

《linux本机进程间通信之UDS详解》文章介绍了Unix域套接字(UDS)的使用方法,这是一种在同一台主机上不同进程间通信的方式,UDS支持三种套接字类型:SOCK_STREAM、SOCK_DGRA... 目录基础概念本机进程间通信socket实现AF_INET数据收发示意图AF_Unix数据收发流程图A

Golang基于内存的键值存储缓存库go-cache

《Golang基于内存的键值存储缓存库go-cache》go-cache是一个内存中的key:valuestore/cache库,适用于单机应用程序,本文主要介绍了Golang基于内存的键值存储缓存库... 目录文档安装方法示例1示例2使用注意点优点缺点go-cache 和 Redis 缓存对比1)功能特性