153

我对thread_localC++11 中的描述感到困惑。我的理解是，每个线程在函数中都有唯一的局部变量副本。所有线程都可以访问全局/静态变量（可能使用锁进行同步访问）。并且thread_local变量对所有线程都是可见的，但只能由定义它们的线程修改？这是对的吗？

4

3 回答 3

185

线程本地存储持续时间是一个术语，用于指代看似全局或静态存储持续时间的数据（从使用它的函数的角度来看），但实际上每个线程都有一个副本。

它添加到当前自动（存在于块/函数期间）、静态（存在于程序持续时间）和动态（存在于分配和释放之间的堆上）。

线程本地的东西在线程创建时就存在，并在线程停止时被处理掉。

下面是一些例子。

考虑一个随机数生成器，其中种子必须在每个线程的基础上维护。使用线程局部种子意味着每个线程都有自己的随机数序列，独立于其他线程。

如果你的种子是随机函数中的一个局部变量，它会在你每次调用它时被初始化，每次都给你相同的数字。如果它是全局的，线程会干扰彼此的序列。

另一个例子是strtok标记化状态存储在特定于线程的基础上。这样，单个线程可以确保其他线程不会搞砸其标记化工作，同时仍然能够在多次调用时保持状态strtok- 这基本上使strtok_r（线程安全版本）冗余。

这两个示例都允许线程局部变量存在于使用它的函数中。在预线程代码中，它只是函数内的静态存储持续时间变量。对于线程，修改为线程本地存储持续时间。

另一个例子是errno. 您不希望errno在一个调用失败后但在检查变量之前修改单独的线程，但您只希望每个线程有一个副本。

该站点对不同的存储持续时间说明符进行了合理的描述。

于 2012-08-16T09:13:22.620 回答
164

当您声明一个变量时thread_local，每个线程都有自己的副本。当您按名称引用它时，将使用与当前线程关联的副本。例如

thread_local int i=0;

void f(int newval){
    i=newval;
}

void g(){
    std::cout<<i;
}

void threadfunc(int id){
    f(id);
    ++i;
    g();
}

int main(){
    i=9;
    std::thread t1(threadfunc,1);
    std::thread t2(threadfunc,2);
    std::thread t3(threadfunc,3);

    t1.join();
    t2.join();
    t3.join();
    std::cout<<i<<std::endl;
}

此代码将输出“2349”、“3249”、“4239”、“4329”、“2439”或“3429”，但不会输出任何其他内容。每个线程都有自己的副本i，分配给它，递增然后打印。运行的线程main也有自己的副本，它在开始时被分配，然后保持不变。这些副本是完全独立的，并且每个都有不同的地址。

只有名称在这方面是特殊的 --- 如果您获取thread_local变量的地址，那么您只有一个指向普通对象的普通指针，您可以在线程之间自由传递。例如

thread_local int i=0;

void thread_func(int*p){
    *p=42;
}

int main(){
    i=9;
    std::thread t(thread_func,&i);
    t.join();
    std::cout<<i<<std::endl;
}

由于 的地址i被传递给线程函数，因此属于主线程的副本i即使是 也可以分配给thread_local。因此，该程序将输出“42”。如果你这样做，那么你需要注意*p在它所属的线程退出后不被访问，否则你会得到一个悬空指针和未定义的行为，就像指向对象被破坏的任何其他情况一样。

thread_local变量在“第一次使用之前”被初始化，所以如果它们从未被给定线程触及，那么它们不一定被初始化。这是为了让编译器避免thread_local在程序中为完全独立且不接触任何变量的线程构造每个变量。例如

struct my_class{
    my_class(){
        std::cout<<"hello";
    }
    ~my_class(){
        std::cout<<"goodbye";
    }
};

void f(){
    thread_local my_class unused;
}

void do_nothing(){}

int main(){
    std::thread t1(do_nothing);
    t1.join();
}

在这个程序中有 2 个线程：主线程和手动创建的线程。两个线程都没有调用f，因此thread_local从不使用该对象。因此未指定编译器是否会构造 0、1 或 2 个实例my_class，输出可能是“”、“hellohellogoodbyegoodbye”或“hellogoodbye”。

于 2012-08-16T10:41:50.240 回答
25

线程本地存储在各个方面都像静态（=全局）存储，只是每个线程都有一个单独的对象副本。对象的生命周期从线程开始（对于全局变量）或第一次初始化（对于块局部静态）开始，并在线程结束时（即被join()调用时）结束。

因此，只有也可以声明的变量static才能声明为thread_local，即全局变量（更准确地说：“在命名空间范围内”的变量）、静态类成员和块静态变量（在这种情况下static是隐含的）。

例如，假设您有一个线程池并且想知道您的工作负载的平衡情况：

thread_local Counter c;

void do_work()
{
    c.increment();
    // ...
}

int main()
{
    std::thread t(do_work);   // your thread-pool would go here
    t.join();
}

这将打印线程使用统计信息，例如使用如下实现：

struct Counter
{
     unsigned int c = 0;
     void increment() { ++c; }
     ~Counter()
     {
         std::cout << "Thread #" << std::this_thread::id() << " was called "
                   << c << " times" << std::endl;
     }
};
于 2012-08-16T09:23:44.920 回答