C++ Thread Local Storage

最新推荐文章于 2025-05-25 13:14:48 发布
最新推荐文章于 2025-05-25 13:14:48 发布
阅读量4.1k 收藏 3
点赞数 1
CC 4.0 BY-SA版权
分类专栏： c/c++ 文章标签： tls
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kevin_darkelf/article/details/78330778




  • Quote 
    • From : http://ju.outofmemory.cn/entry/66238 

我查阅了相关的资料, 发现线程局部存储(TLS)是一个后来者, 产生于多线程概念之后.而在软件发展的早期, 全局变量经常用在库函数中, 用于存储全局信息, 比如errno, 多线程程序产生之后, 全局变量errno就成为所有线程都共享的一个变量, 而实际上, 每个线程都想维护一份自己的errno, 隔离于其他线程.

这个时候, 没人愿意去修改库函数的接口. 于是线程局部存储就诞生了, 根据wikipedia的介绍

Thread-local storage (TLS) is a computer programming method that uses static or global memory local to a thread.

为了在各个平台上都能用上线程局部变量, POSIX Thread定义了一组接口, 用于显式构造使用线程局部存储.

#include <pthread.h>
int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
int pthread_key_delete(pthread_key_t key);
void *pthread_getspecific(pthread_key_t key);
int pthread_setspecific(pthread_key_t key, const void *value);

显式构造线程局部变量的方法, 有一个显著优点就是能注册各种类型的对象, 包括内置对象和自定义对象. 而且对象的销毁方式destructor可以显式告诉pthread_key_create, 这样线程退出的时候, 线程局部变量就可以正常销毁, 不至于造成内存泄露.

优点再多, 也禁不住它太难用了, 于是有人就想在编译器添加新功能, 支持特定关键字__thread, 隐式构造线程局部变量

 __thread int i;
 extern __thread struct state s;
 static __thread char *p;

这样的方式, 使用起来是很方便, 但是需要操作系统, 编译器, 连接器, glibc要相应做出修改, 甚至ELF文件格式都需要调整, 这个Ulrich Drepper在tls.pdf中做了详细的介绍.

另一方面, __thread只支持POD类型, 不能用于定义STL中的容器和类, 比如std::string. 非要这么做, 编译器会报错:

main.cpp:8: error: ‘a’ cannot be thread-local because it has non-POD type ‘std::string’
main.cpp:8: error: ‘a’ is thread-local and so cannot be dynamically initialized

gcc也在文档中专门谈到了Thread-Local, 提到了_thread修饰的变量只能做static initialize

In C++, if an initializer is present for a thread-local variable, it must be a constant-expression, as defined in 5.19.2 of the ANSI/ISO C++ standard.

既然线程局部存储有两种使用方式, 而且各有优缺点, 就有人提出结合二者, 开发一个使用更方便, 又能支持non-POD类型的实现库. 比如 blog 线程局部变量与 __thread

C++11也意识到这个问题, 于是在C++11中引入了新的关键字thread_local, Destructor support for thread_local variables介绍说:

One of the key features is that they support non-trivial constructors and destructors that are called on first-use and thread exit respectively.

除了支持non-POD类型的线程局部变量, 它还提到了上文提到的线程局部变量和动态加载so的问题

The compiler can handle constructors, but destructors need more runtime context. It could be possible that a dynamically loaded library defines and constructs a thread_local variable, but is dlclose()’d before thread exit. The destructor of this variable will then have the rug pulled from under it and crash.

解决的思路是实现函数__cxa_thread_atexit_impl(), 供libstdc++在构造对象的时候调用

int __cxa_thread_atexit_impl (void (*dtor) (void *), void *obj,
                          void *dso_symbol);

连接器(ld)为dso_symbol所属的so维护一个引用计数, 维护由它定义的线程局部变量个数. 如果某个线程局部变量被析构, 那引用计数相应减1, 只有引用计数等于0, dlclose()才能卸载so.

其他视角

Walter Bright 在文章It’s Not Always Nice To Share中认为现有的线程局部变量实现都不友好, 在多线程环境下, static和global的变量应该默认就是TLS的, 而不是shared, 这样单核时代的代码, 比如C运行库,不用改动就可以运行在多线程环境中; 如果应用程序非要全局shared的变量, 那应该加上shared关键字以明确指明.

总结

再回头看看上文的建议, 如果非要在动态加载so中使用线程局部变量.

  1. 显式线程局部变量:
    • pthread_key_create注册了destructor, 在dlclose()调用之前, 确保调用pthread_key_delete()删除线程局部变量
    • pthread_key_create()中的destructor置为NULL.
  2. 隐式线程局部变量: 因为只支持POD类型, 所以可以用在动态加载so中.


  • Methods  
    • thread_local (c++11)



Refferencs:

  • http://blog.youkuaiyun.com/cywosp/article/details/26876231 
  • http://blog.youkuaiyun.com/cywosp/article/details/26469435 
  • http://ju.outofmemory.cn/entry/66238 
  • http://blog.youkuaiyun.com/u013390476/article/details/52129607 



C++的线程本地存储(Thread Local Storage)
夏天的狂风的专栏
06-10 793
在多线程环境中，全局变量和静态变量是所有线程共享的。这意味着，如果一个线程修改了一个全局变量或静态变量的值，那么其他线程将看到这个修改。这可能会导致数据竞争和其他并发问题。为了解决这个问题，我们可以使用线程本地存储。线程本地存储为每个线程提供了一份独立的数据副本。这样，每个线程都可以独立地操作自己的数据，而不会影响其他线程。线程本地存储是C++中处理并发问题的一个重要工具。通过使用线程本地存储，我们可以为每个线程提供一份独立的数据副本，这样每个线程都可以独立地操作自己的数据，而不会影响其他线程。
C++ 中的线程局部存储（Thread Local Storage, TLS）是如何工作的？
panxixia的博客
05-08 472
C++线程局部存储，允许存在不同的值
[并发并行]_[C/C++]_[使用线程本地存储Thread Local Storage(TLS)调用复制文件接口的案例]
11-08
http://blog.youkuaiyun.com/infoworld/article/details/49715355 项目代码,mingw编译.
Thread Local Storage
DDR的专栏
11-16 6980
Instance(单件)机制原本是让代码执行时只有一个实例，但有的时候又希望每个线程各自能有自己的"单件"相互不影响，处理类似的需求最先想到的就是全局表，然后按线程id或是管理线程的key索引到对应的单件上，取全局表的时候需要加锁。 虽然这样也能实现目的，但是代码看上去很不自然。最近发现还是有更自然的方法能实现这一点，就是 TLS 线程本地存储(Thread Local Storage) 用
「震惊」这个C++11关键字让多线程不再需要锁？thread_local实战解密 !
最新发布
Henry313的博客
05-25 730
全局变量是什么？—— 整个程序共享一份局部变量是什么？—— 每个函数调用有一份那 thread_local 变量是什么？—— 每个线程有一份！懂了吧？就是这么简单！下次当你看到多线程程序莫名其妙出问题，先想想是不是该用thread_local！一个关键字，省下一堆 debug 的时间，何乐而不为？如果你觉得这篇文章对你有帮助，别忘了哦~ ，有任何问题也欢迎在评论区留言讨论哦！
C++ 之线程局部存储
Peace
06-30 1474
线程局部存储（TLS,thread local storage）是一个已有的概念。简单地说，所谓线程局部存储变量，就是拥有线程生命期及线程可见性的变量。 线程局部存储实际上是由 单线程程序中的全局/静态变量被应用到多线程程序中 被线程共享而来。 通常情况下，线程会拥有自己的栈空间，但是堆空间、静态数据区（如果从可执行文件的角度来看，静态数据区对应的是可执行文件的data、bss段的数据，而从C/C++语言层面而言，则对应的是全局/静态变量）则是共享的。这样一来，全局、静态变量在这种多线程模型下就总...
tls.rar_TLS_Thread Local Storage_thread local
09-20
"tls.rar_TLS_Thread Local Storage_thread local"这个压缩包文件显然是关于TLS的实例或库，特别是与C++中的`thread_local`关键字相关的应用。 标题中的“TLS”通常指的是Transport Layer Security，是互联网安全...
TLS_TEST.rar_TLS_Thread Local Storage
09-24
在C++中，可以使用`thread_local`关键字声明线程局部变量，而在其他语言如Java中，可以使用`ThreadLocal`类。这种方法在数据库连接池、线程特定缓存或者线程安全的日志记录系统等场景中非常有用。 在提供的压缩包...
c++关键字之thread_local
行知SLAM
01-09 1104
是 C++ 中用于声明线程本地存储的存储期说明符。每个线程都拥有变量的独立副本，不同线程对变量的修改不会相互影响。可用于变量、类的静态成员变量和动态分配的对象，适用于需要线程隔离的变量存储场景。使用时，要注意其性能开销、初始化和析构函数的行为，确保在需要线程隔离的情况下正确使用，避免不必要的资源浪费和内存泄漏。以下是一个更复杂的i < 5;t2.join();return 0;在这个示例中，每个线程都有自己的。
C/C++ 线程局部存储（TLS）
lijian2017的博客
08-21 809
在C或C++中，线程局部存储（Thread-Local Storage，简称TLS）是一种用于存储线程特有数据的方法。这意味着每个线程都可以访问它自己的变量实例，而不会影响到其他线程中的同名变量。这在多线程程序中非常有用，因为它可以避免对共享数据的竞争和同步开销。C++11引入了关键字来简化线程局部存储的使用。在C中，则需要依赖操作系统或编译器提供的特定机制，如GCC的__thread关键字。
【C/C++ 关键字 存储类说明符 】 线程局部变量的魔法：C++ 中 thread_local的用法
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
03-08 1637
thread_local指示对象拥有线程存储期。也就是对象的存储在线程开始时分配，而在线程结束时解分配。每个线程拥有其自身的对象实例。唯有声明为 thread_local 的对象拥有此存储期。 thread_local 能与 static 或 extern 结合一同出现，以调整链接（分别指定内部或外部链接）
Thread Local Storage---__thread 关键字的使用方法
热门推荐
鱼思故渊的专栏
04-04 1万+
__thread是GCC内置的线程局部存储设施，存取效率可以和全局变量相比。__thread变量每一个线程有一份独立实体，各个线程的值互不干扰。可以用来修饰那些带有全局性且值可能变，但是又不值得用全局变量保护的变量。        __thread使用规则：只能修饰POD类型(类似整型指针的标量，不带自定义的构造、拷贝、赋值、析构的类型，二进制内容可以任意复制memset,memcpy,且内容可
【C++11】thread_local/TLS/线程本地存储
jlusuoya的博客
10-21 3265
c++11关键字，简单理解就是thread_local int a，不同的线程读到不的a是不同的存储空间，避免了全局变量冲突，时间关系，简单贴一下别人的总结 http://blog.youkuaiyun.com/u013390476/article/details/52129607 c++之前，有编译器修饰符或api支持等价实现，没有深入研究，具体参考TLS相关的资料，这里给出其一。 http:
C++之thread_local变量
红军不怕远征难，万水千山只等闲
06-21 3791
thread_local 是 C++11 为线程安全引进的变量声明符。表示对象的生命周期属于线程存储期。线程局部存储(Thread Local Storage，TLS)是一种存储期(storage duration)，对象的存储是在线程开始时分配，线程结束时回收，每个线程有该对象自己的实例；如果类的成员函数内定义了 thread_local 变量，则对于同一个线程内的该类的多个对象都会共享一个变量实例，并且只会在第一次执行这个成员函数时初始化这个变量实例。
TLS（Thread Local Storage）线程本地存储
book_withc的专栏
04-08 860
最近开始看些多线程设计。总体觉得，如果只是单单想达到多线程安全的目的，通过加锁很容易实现。多线程的难点在于，如何实现最大的并行度，即如何确定加锁区段，使尽可能多的线程可以工作，而不是简单的给一个大函数整个加锁。         其中提到过TLS，线程本地存储。windows的实现关联到4个函数： （1）TlsAlloc           返回一个index，标示一个存储空间。一个存储空间包
线程本地存储(Thread Local Storage, TLS)分析与使用
u011961033的专栏
10-12 1948
线程本地存储(Thread Local Storage, TLS)分析与使用  线程本地存储(Thread Local Storage, TLS)分析与使用  分类： 技术 2004-08-26 22:00 3220人阅读 评论(8) 收藏 举报  线程本地存储(Thread Local Storage, TLS)简单分析与使用 http://blog.youkuaiyun.com/apemancsdn/ar...
Ubuntu10.10安装arm版本的Qt遇到error: thread-local storage not supported for this target
03-14 1865
Ubuntu10.10安装arm版本的Qt遇到error: thread-local storage not supported for this target 用arm编译的时候却碰到如下错误： thread/qthread_unix.cpp:117: error: thread-local storage not supported for this target make[1]: **
memory_target not supported on this system
weixin_33704234的博客
07-07 100
memory_target not supported on this system oracle11g数据库在执行dbca或者调整sga后重启oracle的时候可能会出现ORA-00845 MEMORY_TARGET not supported on this system 错误。 究其原因就是Linux系统的shm的大小比SGA...
linux c++ thread local原理
02-24
<think>好的，我现在需要回答用户关于Linux下C++中线程本地存储（Thread Local Storage, TLS）原理的问题。用户之前已经询问过ThreadLocal在Java中的实现，现在转向C++在Linux下的实现原理。我需要确保自己理解TLS的概念、实现机制，以及它在Linux环境下的具体工作方式。 首先，我要回忆一下TLS的基本概念。TLS允许每个线程拥有变量的独立副本，这在多线程编程中非常重要，可以避免共享数据导致的竞争条件。在C++中，使用`thread_local`关键字来声明线程本地变量。但用户具体关心的是其底层原理，尤其是在Linux系统中的实现方式。 接下来，我需要考虑Linux下TLS的实现机制。记得Linux主要使用pthread库（如glibc的NPTL实现）来支持多线程，而TLS的实现可能与编译器和操作系统的ABI（Application Binary Interface）有关。可能涉及到的机制包括： 1. **存储模型**：线程本地变量是如何在内存中分配的。每个线程是否有独立的存储区域，例如使用线程控制块（TCB）或者特定的段（如.tdata和.tbss段）来存放这些变量。 2. **访问方式**：线程如何高效访问自己的本地变量。可能需要通过某种指针或寄存器（如FS或GS寄存器在x86架构中的使用）来访问线程特定的内存区域。 3. **动态TLS和静态TLS**：静态TLS是在程序启动时分配的，而动态TLS可以在运行时动态分配。需要区分这两种情况，并说明它们在Linux下的处理方式。 4. **编译器与链接器的角色**：C++中的`thread_local`关键字如何被编译器翻译成特定的存储类别，链接器如何处理这些变量，生成相应的ELF段（如.tdata、.tbss）。 5. **运行时库的支持**：如glibc中的函数（如pthread_key_create, pthread_setspecific, pthread_getspecific）如何管理动态TLS，以及静态TLS的初始化过程。 可能还需要讨论不同架构（如x86_64和ARM）的实现差异，以及线程创建时如何复制或初始化TLS变量。此外，需要考虑性能问题，比如静态TLS访问通常比动态TLS更快，因为可以通过固定的偏移量直接访问，而动态TLS可能需要通过查找表。 另外，用户可能想知道C++11引入的`thread_local`与之前GCC的`__thread`修饰符之间的关系，以及它们在不同标准下的支持情况。 需要验证一些关键点，例如： - 在ELF格式中，TLS变量通常位于.tdata（已初始化）和.tbss（未初始化）段。每个线程在创建时，会为这些段分配内存，并通过特定的段寄存器（如FS或GS）来访问它们。 - 访问静态TLS变量时，编译器生成指令会通过段寄存器加上固定偏移来获取变量的地址。例如，x86_64中使用%fs基址加上偏移量。 - 动态TLS使用键（key）来标识不同的变量，线程通过pthread接口来设置和获取特定于线程的值。这通常涉及哈希表或数组查找，因此效率较低。 需要确保这些信息准确，可能需要查阅相关资料或源码，比如glibc中TLS的实现，或者编译器（如GCC）如何处理`thread_local`关键字。 另外，需要注意用户的问题是关于Linux下C++的实现，因此需要明确区分C++语言层面的特性和系统/编译器层面的实现细节。例如，`thread_local`是C++11标准引入的，而GCC的`__thread`是更早期的扩展，但它们在底层可能共享类似的机制。 可能的误区包括将动态TLS和静态TLS混淆，或者错误地解释寄存器的使用方式。需要确保在解释时清晰地区分不同的情况，并指出它们的优缺点，比如静态TLS的效率更高但数量有限，而动态TLS更灵活但较慢。 最后，需要组织这些信息，以结构化的方式呈现给用户，先介绍基本概念，再深入实现原理，包括存储方式、访问机制、静态与动态TLS的区别，以及相关的编译器与系统支持。</think>### Linux C++ 线程本地存储（TLS）原理详解 --- #### **1. 线程本地存储（TLS）的核心概念** - **目标**：为每个线程提供独立的变量副本，避免多线程共享数据时的竞争。 - **C++关键字**：`thread_local`（C++11 标准引入）或编译器扩展（如 GCC 的 `__thread`）。 - **底层实现依赖**： - **编译器**（如 GCC、Clang）生成特定指令和内存布局。 - **操作系统**（Linux 的线程模型，如 NPTL）提供线程管理支持。 - **ELF 文件格式**（通过 `.tdata`、`.tbss` 等段管理静态 TLS）。 --- #### **2. TLS 的两种实现模式** ##### **2.1 静态 TLS（Static TLS）** - **特点**： - 变量在程序启动时分配，数量固定（由 ELF 文件的 TLS 模板决定）。 - 访问速度快（直接通过段寄存器 + 偏移量访问）。 - **实现机制**： - **内存布局**： - **`.tdata` 段**：已初始化的 TLS 变量。 - **`.tbss` 段**：未初始化的 TLS 变量。 - **线程创建时**：每个线程从 TLS 模板复制初始值到线程私有存储区。 - **访问方式**（以 x86_64 为例）： ```asm mov %fs:0x10, %rax # 通过 FS 寄存器 + 偏移量访问 TLS 变量 ``` ##### **2.2 动态 TLS（Dynamic TLS）** - **特点**： - 变量在运行时动态分配（如 `pthread_key_create`）。 - 灵活性高，但访问速度较慢（需通过键值查找）。 - **实现机制**： - **键值管理**：每个线程维护一个 TLS 数据指针数组，通过键（`pthread_key_t`）索引。 - **操作函数**： ```c pthread_key_create(&key, destructor); // 创建键 pthread_setspecific(key, value); // 设置线程本地值 void* value = pthread_getspecific(key); // 获取线程本地值 ``` - **内存开销**：每个线程需为动态 TLS 维护独立的数据指针数组。 --- #### **3. 静态 TLS 的底层细节（以 Linux x86_64 为例）** ##### **3.1 内存与寄存器** - **FS/GS 寄存器**： - 在 x86_64 中，`FS` 或 `GS` 寄存器指向当前线程的 TLS 存储基址。 - Linux 默认使用 `FS` 寄存器管理 TLS。 - **访问指令**： ```asm mov %fs:0x10, %rax // 读取 TLS 变量（偏移量 0x10） ``` ##### **3.2 TLS 变量的初始化** - **主线程**：直接使用 ELF 文件中的 `.tdata` 和 `.tbss` 段初始化。 - **新线程**（通过 `pthread_create`）： 1. 从主线程的 TLS 模板复制初始值。 2. 分配独立的 TLS 存储区，并设置 `FS` 寄存器指向该区域。 ##### **3.3 性能优势** - **直接寻址**：无哈希计算或链表遍历，访问速度与全局变量接近。 - **缓存友好**：连续内存布局减少缓存未命中。 --- #### **4. 动态 TLS 的实现（以 pthread 库为例）** ##### **4.1 键值存储结构** - **全局键表**：记录所有已分配的键及其析构函数。 - **线程私有数据**：每个线程维护一个 `void*` 数组，通过键的索引访问值。 ##### **4.2 操作流程** 1. **创建键**： ```c pthread_key_create(&key, destructor); ``` - 分配一个未使用的键索引，注册析构函数。 2. **设置值**： ```c pthread_setspecific(key, value); ``` - 将值存入当前线程的 TLS 数组的对应索引位置。 3. **获取值**： ```c void* value = pthread_getspecific(key); ``` - 从当前线程的 TLS 数组的对应索引位置读取值。 ##### **4.3 性能瓶颈** - **间接访问**：需通过键索引多级寻址，速度慢于静态 TLS。 - **锁竞争**：全局键表的操作可能涉及锁（尽管现代实现通常优化为无锁结构）。 --- #### **5. 静态 TLS 与动态 TLS 的对比** | **特性** | **静态 TLS** | **动态 TLS** | |-------------------|---------------------------------------|---------------------------------------| | **分配时机** | 程序启动时 | 运行时动态分配 | | **访问速度** | 快（直接寄存器寻址） | 慢（需键值查找） | | **灵活性** | 固定数量，需提前定义 | 支持动态创建和销毁 | | **适用场景** | 高频访问的线程本地变量 | 需要动态管理的临时数据 | --- #### **6. C++ `thread_local` 关键字的实现** - **编译器行为**： - 若变量在编译期可知大小且数量固定，优先使用静态 TLS。 - 否则（如动态加载的库中使用 `thread_local`），退化为动态 TLS。 - **示例代码**： ```cpp thread_local int val = 42; // 静态 TLS（若编译器支持） ``` - **与 `__thread` 的关系**： - GCC 的 `__thread` 是 C++11 前对静态 TLS 的扩展，行为与 `thread_local` 类似。 - C++11 标准化后，`thread_local` 兼容性更好。 --- #### **7. 常见问题与优化** - **TLS 的数量限制**： - 静态 TLS 的段大小有限（依赖 ELF 模板），过多变量可能导致链接错误。 - 动态 TLS 无硬性限制，但需注意内存开销。 - **性能优化**： - 优先使用静态 TLS 存储高频访问的变量。 - 避免在关键路径频繁调用 `pthread_getspecific`。 --- ### 总结 - **静态 TLS**：通过 ELF 段和寄存器直接寻址实现高效访问，适用于固定变量。 - **动态 TLS**：基于键值管理的灵活方案，适用于运行时动态需求。 - **C++ `thread_local`**：由编译器根据上下文选择最优实现，结合两种 TLS 机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值