Linux 线程局部存储

目录

• 1. 使用NPTL库函数实现线程局部存储
  • NPTL创建线程局部存储过程
• 2. 使用__thread实现线程局部存储
• 3. C++中通过ThreadLocal实现封装线程局部存储
• 4. 线程单例对象ThreadLocalSingleton
• 小结
• 参考

Linux有2种方法可以实现线程局部存储：
1）使用NTPL提供的函数；
2）使用编译器扩展的__thread关键字。

NPTL（Native POSIX Thread Library），顾名思义，本地POSIX线程库。

1. 使用NPTL库函数实现线程局部存储

NPTL提供实现线程局部存储功能的接口：

#include <pthread.h>

int pthread_key_create(pthread_key_t* key, void (*destructor)(void*));

int pthread_key_delete(pthread_key_t key);

int pthread_setspecific(pthread_key_t key, const void* value);

void* pthread_getspecific(pthread_key_t key);

pthread_key_create 为线程局部存储创建一个新键，并通过给key赋值，返回给用户。而参数key需要给进程中所有线程使用，因此key应指向一个全局变量。

参数destructor指向一个自定义函数，主要用于是否value指向的资源：

void destructor(void *value)
{
    // 释放value指向的资源
}

pthread_key_delete 删除由pthread_key_create 创建的线程局部存储的数据。参数key由pthread_key_create 赋值。

pthread_setspecific和pthread_getspecific用于线程局部数据管理：
pthread_getspecific返回绑定到key绑定的value；
pthread_setspecific用于绑定value到key。
key由pthread_key_create 创建，不同的线程可以绑定不同的value到相同的key。
而value是一个指向动态分配的内存块，为调用线程独有。

NPTL创建线程局部存储过程

NPTL实现下，一个进程中，由pthread_key_create 创建的key（对应一个槽位）最多1024个。pthread_key_create 调用成功时，会将一个<1024的值，填入第一个传入参数key指向的pthread_key_t变量中。
也就是说，记录槽位分配区块的数据结构pthread_keys是进程唯一的。槽位初始值为0。

一个1024个槽位：pthread_keys[0...1023]。

此时，各线程还没数据和该key相关联。接下来，需要用pthread_setspecific绑定key和线程关联的数据，用pthread_getspecific得到与key绑定的、跟线程关联的数据。

示例：
使用NPTL创建的线程局部存储，分别在多个线程中设置、访问，并写入文件。

#include <malloc.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

/* 为每个线程保存文件指针的TSD键值，根据键值可以找到线程各自的Data */
static pthread_key_t thread_log_key;

void write_to_thread_log(const char* message)
{
    FILE* thread_log = (FILE*) pthread_getspecific(thread_log_key);
    fprintf(thread_log, "%s\n", message);
}

void fn_close_thread_log(void* thread_log)
{
    fclose((FILE*)thread_log);
}

void* thread_function(void* arg)
{
    char thread_log_filename[128];
    FILE* thread_log;

    snprintf(thread_log_filename, sizeof(thread_log_filename),
             "thread%ld.log", (unsigned long)pthread_self());
    thread_log = fopen(thread_log_filename, "w");

    /* 将文件指针保存在thread_log_key标识的TSD中 */
    pthread_setspecific(thread_log_key, thread_log);

    write_to_thread_log("Thread starting.");
    return NULL;
}

int main()
{
    int i;
    pthread_t threads[5];

    pthread_key_create(&thread_log_key, fn_close_thread_log);
    for (i = 0; i < 5; ++i) {
        pthread_create(&(threads[i]), NULL, thread_function, NULL);
    }

    for (i = 0; i < 5; ++i) {
        pthread_join(threads[i], NULL);
    }
    return 0;
}

运行结果：
在可执行目标文件所指目录中，生成多个线程对应的文件，每个文件名对应一个线程tid。

2. 使用__thread实现线程局部存储

NTPL提供的函数太过繁琐，有人想到在编译器中添加通过添加关键字__thread，以增进新功能，隐式构造线程局部变量。
例如，下面的声明，表示val在当前进程的每个线程中，都会有该变量的一个拷贝，直到线程退出为止。

__thread int val = 0;

有几点需要注意：

• 如果变量声明中用来关键字static extern，那么关键字__thread应该紧随其后。
• 声明时，可以正常初始化。
• 可以通过取地址操作符（&），获取到线程局部变量的地址。

将1）中使用NPTL实现线程局部存储的示例，用__thread改写：

#include <malloc.h>
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

__thread FILE* thread_log = NULL;
void write_to_thread_log(const char* message)
{
    fprintf(thread_log, "%s\n", message);
}

void *thread_function(void* arg)
{
    char thread_log_filename[128];
    sprintf(thread_log_filename, "thread%ld.log", (unsigned long)pthread_self());

    thread_log = fopen(thread_log_filename, "w");
    write_to_thread_log("Thread starting.");

    fclose(thread_log);
    return NULL;
}

int main()
{
    int i;
    pthread_t threads[5];

    for (i = 0; i < 5; ++i)
        pthread_create(&(threads[i]), NULL, thread_function, NULL);
    for (i = 0; i < 5; ++i)
        pthread_join(threads[i], NULL);
    return 0;
}

3. C++中通过ThreadLocal实现封装线程局部存储

自定义一个class ThreadLocal，用RAII方式管理pthread_key，以简化线程局部存储的使用。

template <typename T>
class ThreadLocal : noncopyable
{
public:
    ThreadLocal()
    {
        pthread_key_create(&pkey_, &ThreadLocal::destructor);
    }

    ~ThreadLocal()
    {
        pthread_key_delete(pkey_);
    }

    T& value()
    {
        T* perThreadValue = static_cast<T*>(pthread_getspecific(pkey_));
        if (!perThreadValue)
        {
            T* newObj = new T();
            pthread_setspecific(pkey_, newObj);
            perThreadValue = newObj;
        }
        return *perThreadValue;
    }

private:
    static void destructor(void *x)
    {
        T* obj = static_cast<T*>(x);
        typedef char T_must_be_complete_type[sizeof(T) == 0 ? -1 : 1];
        T_must_be_complete_type dummy; (void)dummy;
        delete obj;
    }

    pthread_key_t pkey_;
};

使用ThreadLocal，为每个线程分配一个局部存储class Test，包装了名称字符串（name_）

#include "muduo/base/ThreadLocal.h"
#include "muduo/base/CurrentThread.h"
#include "muduo/base/Thread.h"

#include <stdio.h>

class Test : muduo::noncopyable
{
public:
    Test()
    {
        printf("tid=%d, constructing %p\n", muduo::CurrentThread::tid(), this);
    }
    ~Test()
    {
        printf("tid=%d, destructing %p %s\n", muduo::CurrentThread::tid(), this, name_.c_str());
    }

    const muduo::string& name() const { return name_; }
    void setName(const muduo::string& n) { name_ = n; }


private:
    muduo::string name_;
};

muduo::ThreadLocal<Test> t_testObj1;
muduo::ThreadLocal<Test> t_testObj2;

void print()
{
    printf("tid=%d, obj1 %p name=%s\n",
           muduo::CurrentThread::tid(),
           &t_testObj1.value(),
           t_testObj1.value().name().c_str());
    printf("tid=%d, obj2 %p name=%s\n",
           muduo::CurrentThread::tid(),
           &t_testObj2.value(),
           t_testObj2.value().name().c_str());
}

void threadFunc()
{
    print();
    t_testObj1.value().setName("changed 1");
    t_testObj2.value().setName("changed 2");
    print();
}

int main()
{
    t_testObj1.value().setName("main one");
    print();
    muduo::Thread t1(threadFunc);
    t1.start();
    t1.join();
    t_testObj2.value().setName("main two");
    print();
    return 0;
}

运行结果：
ThreadLocal变量，虽然名称一样，在main线程和t1线程中，存储的空间和值是不一样的。

tid=104305, constructing 0x19d2c50
tid=104305, obj1 0x19d2c50 name=main one
tid=104305, constructing 0x19d2c70
tid=104305, obj2 0x19d2c70 name=

tid=104306, constructing 0x7f7c300008c0
tid=104306, obj1 0x7f7c300008c0 name=
tid=104306, constructing 0x7f7c300008e0
tid=104306, obj2 0x7f7c300008e0 name=
tid=104306, obj1 0x7f7c300008c0 name=changed 1
tid=104306, obj2 0x7f7c300008e0 name=changed 2
tid=104306, destructing 0x7f7c300008c0 changed 1
tid=104306, destructing 0x7f7c300008e0 changed 2

tid=104305, obj1 0x19d2c50 name=main one
tid=104305, obj2 0x19d2c70 name=main two

4. 线程单例对象ThreadLocalSingleton

结合前面的单例对象，如何让每个线程拥有同一个类的不同单例对象？
可以用ThreadLocalSingleton类，所有线程共享一个ThreadLocalSingleton::instance，但每个线程都持有一个不同的t_value_（线程局部存储，NPTL实现的TSD）。

template<typename T>
class ThreadLocalSingleton : noncopyable
{
public:
    static T& instance()
    {
        if (!t_value_)
        {
            t_value_ = new T();
            deleter_.set(t_value_);
        }
        return *t_value_;
    }

    static T* pointer()
    {
        return t_value_;
    }

private:
    ThreadLocalSingleton();
    ~ThreadLocalSingleton();
    
    static void destructor(void* obj)
    {
        assert(obj == t_value_ );
        typedef char T_must_be_complete_type[sizeof(T) == 0 ? -1 : 1];
        T_must_be_complete_type dummy; (void) dummy;
        delete t_value_;
        t_value_ = 0;
    }

    class Deleter
    {
    public:
        Deleter()
        {
            pthread_key_create(&pkey_, &ThreadLocalSingleton::destructor);
        }

        ~Deleter()
        {
            pthread_key_delete(pkey_);
        }

        void set(T* newObj)
        {
            assert(pthread_getspecific(pkey_) == NULL);
            pthread_setspecific(pkey_, newObj);
        }

        pthread_key_t pkey_;
    };

    static __thread T* t_value_;
    static Deleter deleter_;
};

// static变量定义, 类内只是声明
template<typename T>
__thread * ThreadLocalSingleton<T>::t_value_ = 0;

template<typename T>
typename ThreadLocalSingleton<T>::Deleter ThreadLocalSingleton<T>::deleter_;

使用ThreadLocalSingleton

void threadFunc(const char* changeTo)
{
    printf("tid=%d, %p name=%s\n", 
            muduo::CurrentThread::tid(),
            &muduo::ThreadLocalSingleton<Test>::instance(),
            muduo::ThreadLocalSingleton<Test>::instance().name().c_str());
    muduo::ThreadLocalSingleton<Test>::instance().setName(changeTo)
    printf("tid=%d, %p name=%s\n", 
            muduo::CurrentThread::tid(),
            &muduo::ThreadLocalSingleton<Test>::instance(),
            muduo::ThreadLocalSingleton<Test>::instance().name.c_str());
// 没必要手动delete
// muduo::ThreadLocalSingleton<Test>::destructor(); 会销毁
}

int main()
{
    muduo::ThreadLocalSingleton<Test>::instance().setName("main one");
    muduo::Thread t1(std::bind(threadFunc, "thread1"));
    muduo::Thread t2(std::bind(threadFunc, "thread2"));
    t1.start();
    t2.start();
    t1.join();
    printf("tid=%d, %p name=%s\n",
            muduo::CurrentThread::tid(),
            &muduo::ThreadLocalSingleton<Test>::instance(),
            muduo::ThreadLocalSingleton<Test>::instance().name().c_str());
    t2.join();
    return 0;
}

小结

对于线程本地存储TLS，什么时候使用NPTL库提供的TSD机制，什么使用__thread？
NPTL库提供的TSD机制，更通用。对于POD数据类型，可以用__thread。

参考

[1]高峰, 李彬. Linux环境编程:从应用到内核[M]. 机械工业出版社, 2016.
[2]陈硕. Linux多线程服务端编程:使用muduo C++网络库[M]. 电子工业出版社, 2013.