C++ 的存储类型与新的 thread

1 C++ 的存储类型

1.1 存储周期（Storage duration）

存储周期表示一个变量的存储空间持续的时间，它应该与对象的语义生命周期一致（或至少不小于对象的语义生命周期）。C++ 98从 C 继承了三种存储周期，分别是静态存储周期（static storage duration）、自动存储周期（automatic storage duration）和动态存储周期（dynamic storage duration），C++ 11 又增加了一种线程存储周期（thread storage duration）。

存储周期只是一个概念，是程序语义范畴内的东西，但不是语法的范畴。这个概念在语法上的表示则由下一节介绍的存储类型说明符（Storage class specifiers）展示。

1.2 存储类型说明符（Storage class specifiers）

存储类型说明符（Storage class specifiers）也被称为存储类型，它们是变量声明语法中类型说明符的一部分，它们和变量名的范围一起控制变量的两个独立属性，即存储周期（storage duration）和链接属性（ linkage）。C++ 98从 C 语言继承了 auto、register、static 和 extern 四种类型，同时补充了一种 mutable，C++ 11 针对线程存储周期又增加了一个线程本地存储的说明符 thread_local。关于这几个存储类型说明符的作用，请参考下表：

类型	说明	备注
auto	自动存储周期，也是变量的默认存储类型，由变量的域范围决定变量的存储周期，比如局部变量的存储周期随着域的结束而结束，而全局变量的存储周期则与程序的运行时间一致	从 C++11 开始，显示使用 auto 存储类型会导致编译错误。比如 auto int i; 会导致编译错误
register	也是自动存储类型，不过暗示编译器会择机将其放置在寄存器中以提高数据存取的效率	在 C++ 17 被移除标准，以后应避免使用这个存储类型
static	静态或线程存储周期，采用内部链接（对于不属于匿名名字空间（anonymous namespace）的静态类成员，采用外部链接）	static 表示一个对象具有静态存储持续周期。它的生命周期是程序的整个执行过程，其存储的值在程序启动之前只初始化一次
extern	静态或线程存储周期，采用外部链接
mutable	严格来说，这不是一种存储类型，因为它既不影响变量的存储周期，也不影响链接属性，它只是表示一种可以“不动声色”地修改常量对象成员的机会。
thread_local	线程存储类型

1.3 存储类型说明符与存储周期的关系

C++ 中变量存储周期与变量类型说明符的关系如下表所示：

存储周期	变量类型与类型说明符
自动存储周期	显式使用 register 声明的变量，或隐式声明为 static 或 extern 的作用域内部变量，没有明确指定存储类型说明符的变量
静态存储周期	1、非 thread_local 声明的全局（非局部）变量；2、非动态生成（使用 new 创建）的非局部变量；3、用 static 声明的局部变量、全局变量和类成员变量
动态存储周期	1、使用 new 表达式创建（非 placement_new），并且使用 delete 销毁的对象；2、使用其他动态分配函数和动态释放函数管理的对象存储位置
线程存储周期	使用 thread_local 声明的所有变量，包括局部变量、全局变量和成员变量

2 thread_local

这里介绍一下 C++ 11 新补充的线程本地存储和 thread_local 存储类型说明符。线程存储周期是指对象在线程开始时创建，并在线程结束时销毁。thread_local 说明符用于声明一个变量是线程本地存储类型，对于这种类型的变量，每个线程都会维护一个该变量的实例，各个线程的变量实例之间互相不影响，这也就是线程本地存储的意义。thread_local 说明符可以和 static 或 extern 说明符一起使用，用来描述变量的链接属性是静态链接还是外部链接。

2.1 thread_local 应用例子

2.1.1 thread_local 与全局变量

上一节提到，使用 thread_local 声明的变量会在每个线程中维护一个该变量的实例，线程之间互不影响，这里我们用一个普通的全局变量和一个 thread_local 类型的全局变量做对比，说明一下这种存储类型的变量有什么性质。

std::mutex print_mtx;    //避免打印被冲断

thread_local int thread_count = 1;
int global_count = 1;

void ThreadFunction(const std::string& name, int cpinc) {
    for (int i = 0; i < 5; i++) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::lock_guard<std::mutex> lock(print_mtx);
        std::cout << "thread name: " << name << ", thread_count = " << thread_count 
                                             << ", global_count = " << global_count++ << std::endl;
        thread_count += cpinc;
    }
}

int main() {
    std::thread t1(ThreadFunction, "t1", 2);
    std::thread t2(ThreadFunction, "t2", 5);
    t1.join();
    t2.join();
}

程序打印的结果如下：

thread name: t2, thread_count = 1, global_count = 1
thread name: t1, thread_count = 1, global_count = 2
thread name: t1, thread_count = 3, global_count = 3
thread name: t2, thread_count = 6, global_count = 4
thread name: t1, thread_count = 5, global_count = 5
thread name: t2, thread_count = 11, global_count = 6
thread name: t1, thread_count = 7, global_count = 7
thread name: t2, thread_count = 16, global_count = 8
thread name: t1, thread_count = 9, global_count = 9
thread name: t2, thread_count = 21, global_count = 10

可以看出来每个线程中的 thread_count 都是从 1 开始打印，这印证了 thread_local 存储类型的变量会在线程开始时被初始化，每个线程都初始化自己的那份实例。另外，两个线程的打印数据也印证了 thread_count 的值在两个线程中互相不影响。作为对比的 global_count 是静态存储周期，就没有这个特性，两个线程互相产生了影响。

2.1.2 thread_local 与 static

thread_local 也可以用于局部变量的声明，其作用域的约束与局部静态变量类似，但是其存储与局部静态变量不一样，首先是每个线程都有自己的变量实例，其次是其生命周期与线程一致，而局部静态变量的声明周期是直到程序结束。下面再用一个例子演示一下：

void DoPrint(const std::string& name, int cpinc) {
    static int static_count = 1;
    thread_local int local_count = 1;
    std::cout << "thread name: " << name << ", local_count = " << local_count
        << ", static_count = " << static_count++ << std::endl;
    local_count += cpinc;
}

void ThreadFunction(const std::string& name, int cpinc) {
    for (int i = 0; i < 5; i++) {
        std::this_thread::sleep_for(std::chrono::seconds(1));
        std::lock_guard<std::mutex> lock(print_mtx);
        DoPrint(name, cpinc);
    }
}

int main() {
    std::thread t1(ThreadFunction, "t1", 2);
    std::thread t2(ThreadFunction, "t2", 5);
    t1.join();
    t2.join();
}

在上面的例子中，static_count 和 local_count 变量的作用域都仅限于 DoPrint() 函数内部，但是存储类型不一样，local_count 在每个线程中的实例独立初始化，独立变化，线程之间没有影响，而局部静态变量 static_count 则在两个线程之间互相影响。从结果打印的情况也印证了这一点：

thread name: t1, local_count = 1, static_count = 1
thread name: t2, local_count = 1, static_count = 2
thread name: t1, local_count = 3, static_count = 3
thread name: t2, local_count = 6, static_count = 4
thread name: t2, local_count = 11, static_count = 5
thread name: t1, local_count = 5, static_count = 6
thread name: t1, local_count = 7, static_count = 7
thread name: t2, local_count = 16, static_count = 8
thread name: t1, local_count = 9, static_count = 9
thread name: t2, local_count = 21, static_count = 10

2.1.3 thread_local 与成员变量

thread_local 可以用于类的成员变量，但是只能用于静态成员变量。这很容易理解，C++ 不能在对象只有一份拷贝的情况下弄出多个成员变量的实例，但是静态成员就不一样了，每个类的静态成员共享一个实例，改成线程局部存储比较容易实现，也容易理解。

2.1.4 thread_local 与初始化

考虑一下下面的代码，想象会创建几个类 Foo 的实例？

struct Foo
{
    Foo(int a) { m_a = a; }
    int m_a;
};

for (int i = 0; i < 5; i++)
{
    thread_local Foo f(3);
    f.m_a++;
    std::cout << f.m_a;
}

答案是只有一个 Foo 的实例会被创建，并且 f(3) 的初始化在线程开始的时候做一次，最终打印的结果是 45678，并且 f 将在线程结束的时候被调用析构函数。如果不使用 thread_local，则会构造 5 个 Foo 的实例，并且销毁 5 次，最终打印的结果是 44444。

2.2 thread_local 的意义

在 thread_local 提出之前，你无法为一个线程定义自己的全局变量（线程级别的全局变量），只能将全局变量定义在父进程中，由所有的线程（不同种类的线程）共享使用（操作系统可能会提供线程局部存储之类的支持，但那不是 C++ 语言规范层面的东西）。但是当程序复杂到一定程度的时候，线程之间的串扰就在所难免，同时也增大了多线程编码的复杂度。前面的例子展示了 thread_local 的用法，每个线程共享一个属于本线程的变量的实例，相当于线程有了自己的全局变量。

另一个常用来解释 thread_local 的意义的例子就是随机数的生成。我们知道的随机数生成器都是伪随机数生成器，其随机性取决于种子（seed）的变化。如果一个函数使用局部变量设置随机数发生器的种子，那么它在每个使用这个函数的线程中都会被初始化，由于使用了相同的种子，每个线程将得到一样的随机数序列，这就使得多线程也不那么随机了。如果使用 thread_local 类型的种子，则每个线程维护自己的种子，从而使得每个线程都能得到不同的随机数序列，真正起到随机数的作用。

其他的例子就是线程不安全问题，C 标准库的错误码 errno，还有 strtok() 等函数就是线程不安全的例子。有了 thread_local ，就可以用很小的改动解决这些函数的线程不安全问题。也不需要像有些编译器那样，专门提供一套线程安全的标准库，用过的人都知道，很多函数的参数定义都是不兼容的，对现有代码的改造成本非常高。

关注公众号，与作者互动：
在这里插入图片描述 ## 参考资料

[1] Marc Gregoire, Professional C++ (Fifth Edition), John Wiley & Sons, Inc., 2021
[2] Scott Meyers, Effective Modern C++, O’Reilly, 2015
[3] Bjarne Stroustrup. The C++ Programming Language, Fourth Edition. Pearson. 2013（中文版：机械工业出版社）
[4] Bartłomiej Filipek. C++17 In Detail. Leanpub. 2019
[5] Nicolai M. Josuttis, C++20 - The Complete Guide, http://leanpub.com/cpp20’
[6] Jacek Galowicz. C++17 STL Cookbook. Packtpub. 2017
[7] https://en.cppreference.com/w/c/thread/thread_local