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.
原文链接: https://www.cnblogs.com/fortunely/p/15934054.html
欢迎关注
微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍;
也有高质量的技术群,里面有嵌入式、搜广推等BAT大佬
原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/402732
非原创文章文中已经注明原地址,如有侵权,联系删除
关注公众号【高性能架构探索】,第一时间获取最新文章
转载文章受原作者版权保护。转载请注明原作者出处!