C/C++编程：线程私有空间封装

阳光穿透心脏的1/2处 2022-12-29 09:11 156阅读 0赞

# 基础 #

[linux多线程之线程私有存储空间][linux]  
1、Posix 标准下 “动态 TLS 模型” 使用举例：

#include <stdlib.h>
    #include <stdio.h>
    #include <pthread.h>
    
    static pthread_key_t key;
    
    // 每个线程退出时回调此函数来释放线程局部变量的动态分配的内存
    static void destructor(void *arg)
    {
        
        free(arg);
        printf("destructor\n");
    }
    
    static init(void)
    {
        
        // 生成进程空间内所有线程的线程局部变量所使用的键值: 无论是哪一个线程创建，其他所有的线程都是可见的，即一个进程中只需phread_key_create()一次
        pthread_key_create(&key, destructor);
        printf("constructor\n");
    }
    
    static void *thread_fn(void *arg)
    {
        
        char *ptr;
    
        // 获得本线程对应 key 键值的线程局部变量
        ptr = pthread_getspecific(key);
        if (ptr == NULL) {
        
            // 如果为空，则生成一个
            ptr = malloc(256);
            // 设置对应 key 键值的线程局部变量
            pthread_setspecific(key, ptr);
        }
    
         /* do something */
    
        return (NULL);
    }
    
    static void run(void)
    {
        
        int   i, n = 10;
        pthread_t tids[10];
    
        // 创建新的线程
        for (i = 0; i < n; i++) {
        
            pthread_create(&tids[i], NULL, thread_fn, NULL);
        }
    
        // 等待所有线程退出
        for (i = 0; i < n; i++) {
        
            pthread_join(tids[i], NULL);
        }
    }
    
    int main(int argc, char *argv[])
    {
        
        init();
        run();
        return (0);
    }

可以看出，在同一进程内的各个线程使用同样的线程局部变量的键值来“取得/设置”线程局部变量，所以在主线程中先初始化以获得一个唯一的键值。如果不 能在主线程初始化时获得这个唯一键值怎么办？ Posix 标准规定了另外一个函数：pthread\_once(pthread\_once\_t \*once\_control, void (\*init\_routine)(void)), 这个函数可以保证 init\_routine 函数在多线程内仅被调用一次，稍微修改以上例子如下：  
![在这里插入图片描述][20201221143326203.png]  
2、优化

#include <stdlib.h>
    #include <stdio.h>
    #include <pthread.h>
    #include <zconf.h>
    
    static pthread_key_t key;
    
    // 每个线程退出时回调此函数来释放线程局部变量的动态分配的内存
    static void destructor(void *arg)
    {
        
        free(arg);
        printf("destructor\n");
    
    }
    
    static void init(void)
    {
        
        // 生成进程空间内所有线程的线程局部变量所使用的键值
        pthread_key_create(&key, destructor);
        sleep(3);
        printf("constructor\n");
    
    }
    
    static pthread_once_t once_control = PTHREAD_ONCE_INIT;
    
    static void *thread_fn(void *arg)
    {
        
        char *ptr;
    
        // 多个线程调用 pthread_once 后仅能是第一个线程才会调用 init 初始化
        // 函数，其它线程虽然也调用 pthread_once 但并不会重复调用 init 函数,
        // 同时 pthread_once 保证 init 函数在完成前其它线程都阻塞在
        // pthread_once 调用上（这一点很重要，因为它保证了初始化过程）
        pthread_once(&once_control, init);
    
        // 获得本线程对应 key 键值的线程局部变量
        ptr = pthread_getspecific(key);
        if (ptr == NULL) {
        
            // 如果为空，则生成一个
            ptr = malloc(256);
            // 设置对应 key 键值的线程局部变量
            pthread_setspecific(key, ptr);
        }
        /* do something */
    
        return (NULL);
    }
    
    static void run(void)
    {
        
        int   i, n = 10;
        pthread_t tids[10];
    
        // 创建新的线程
        for (i = 0; i < n; i++) {
        
            pthread_create(&tids[i], NULL, thread_fn, NULL);
        }
    
        // 等待所有线程退出
        for (i = 0; i < n; i++) {
        
            pthread_join(tids[i], NULL);
        }
    }
    
    int main(int argc, char *argv[])
    {
        
        run();
        return (0);
    }

3、使用ACL库创建线程局部变量

接口如下

/**
     * 设置每个进程内线程局部变量的最大数量
     * @param max {int} 线程局部变量限制数量
     */
    int acl_pthread_tls_set_max(int max);
    
    /**
     * 获得当前进程内线程局部变量的最大数量限制
     * @return {int} 线程局部变量限制数量
     */
    int acl_pthread_tls_get_max(void);
    
    /**
     * 获得对应某个索引键的线程局部变量，如果该索引键未被初始化则初始之
     * @param key_ptr {acl_pthread_key_t} 索引键地址指针，
     *         如果是由第一个线程调用且该索引键还未被初始化(其值应为 -1)，则自动初始化该索引键并将键值赋予该指针地址，同时会返回NULL;
     *        如果 key_ptr 所指键值已经初始化，则返回调用线程对应此索引键值的线程局部变量
     * @return {void*} 对应索引键值的线程局部变量
     */
    void *acl_pthread_tls_get(acl_pthread_key_t *key_ptr);
    
    /**
     * 设置某个线程对应某索引键值的线程局部变量及自动释放函数
     * @param key {acl_pthread_key_t} 索引键值，必须是 0 和acl_pthread_tls_get_max() 返回值之间的某个有效的数值，该值必须是由 acl_pthread_tls_get() 初始化获得的
     * @param ptr {void*} 对应索引键值 key 的线程局部变量对象
     * @param free_fn {void (*)(void*)} 线程退出时用此回调函数来自动释放
     *    该线程的线程局部变量 ptr 的内存对象
     * @return {int} 0: 成功; !0: 错误
     * @example:
     *    static void destructor(void *arg)
     *    {
     *        acl_myfree(arg};
     *    }
     *    static void test(void)
     *    {
     *        static acl_pthread_key_t key = -1;
     *        char *ptr;
     *
     *        ptr = acl_pthread_tls_get(&key);
     *        if (ptr == NULL) {
     *            ptr = (char*) acl_mymalloc(256);
     *            acl_pthread_tls_set(key, ptr, destructor);
     *        }
     *    }
     */
     int acl_pthread_tls_set(acl_pthread_key_t key, void *ptr, void (*free_fn)(void *));
      int acl_pthread_tls_del(pthread_key_t key);

实现如下：

#define	ACL_TLS_OUT_OF_INDEXES          0xffffffff
    
    # define ACL_PTHREAD_ONCE_INIT           PTHREAD_ONCE_INIT
    
    
    #include <acl_thread.h>
    #include <acl_malloc.h>
    #include <acl_msg.h>
    #include <asm/errno.h>
    
    
    
    
    typedef struct {
        
        pthread_key_t key;
        void *ptr;
        void (*free_fn)(void*);
    } TLS_CTX;
    
    static int acl_tls_ctx_max = 1024;
    static pthread_once_t __tls_ctx_control_once = PTHREAD_ONCE_INIT;
    static pthread_key_t __tls_ctx_key = (pthread_key_t) ACL_TLS_OUT_OF_INDEXES;
    
    int acl_pthread_tls_set_max(int max)
    {
        
        if (max <= 0) {
        
            acl_set_error(EINVAL);
            return EINVAL;
        } else {
        
            acl_tls_ctx_max = max;
            return 0;
        }
    }
    
    int acl_pthread_tls_get_max(void)
    {
        
        return acl_tls_ctx_max;
    }
    
    /* 线程退出时调用此函数释放属于本线程的局部变量 */
    static void tls_ctx_free(void *ctx)
    {
        
        TLS_CTX *tls_ctxes = (TLS_CTX*) ctx;
        int   i;
    
        for (i = 0; i < acl_tls_ctx_max; i++) {
        
            if (tls_ctxes[i].ptr != NULL && tls_ctxes[i].free_fn != NULL) {
        
                tls_ctxes[i].free_fn(tls_ctxes[i].ptr);
            }
        }
        acl_default_free(__FILE__, __LINE__, tls_ctxes);
    }
    
    static void tls_ctx_once_init(void)
    {
        
       pthread_key_create(&__tls_ctx_key, tls_ctx_free);
    }
    
    void *acl_pthread_tls_get(pthread_key_t *key_ptr)
    {
        
        const char *myname = "acl_pthread_tls_get";
        TLS_CTX *tls_ctxes;
        int   i;
    
        pthread_once(&__tls_ctx_control_once, tls_ctx_once_init);
        if (__tls_ctx_key == (pthread_key_t) ACL_TLS_OUT_OF_INDEXES) {
        
            acl_msg_error("%s(%d): __tls_ctx_key invalid, tid(%lu)",
                          myname, __LINE__, (unsigned long) pthread_self());
            return NULL;
        }
        tls_ctxes = (TLS_CTX*) pthread_getspecific(__tls_ctx_key);
        if (tls_ctxes == NULL) {
        
            /* 因为该线程中不存在该线程局部变量，所以需要分配一个新的 */
            tls_ctxes = (TLS_CTX*) acl_default_malloc(__FILE__, __LINE__,
                                                      acl_tls_ctx_max * sizeof(TLS_CTX));
            if (pthread_setspecific(__tls_ctx_key, tls_ctxes) != 0) {
        
                acl_default_free(__FILE__, __LINE__, tls_ctxes);
                acl_msg_error("%s(%d): pthread_setspecific: %s, tid(%lu)",
                              myname, __LINE__, acl_last_serror(),
                              (unsigned long) pthread_self());
                return NULL;
            }
            /* 初始化 */
            for (i = 0; i < acl_tls_ctx_max; i++) {
        
                tls_ctxes[i].key = (pthread_key_t) ACL_TLS_OUT_OF_INDEXES;
                tls_ctxes[i].ptr = NULL;
                tls_ctxes[i].free_fn = NULL;
            }
    
        }
    
        /* 如果该键已经存在则取出对应数据 */
        if ((int) (*key_ptr) >= 0 && (int) (*key_ptr) < acl_tls_ctx_max) {
        
            if (tls_ctxes[(int) (*key_ptr)].key == *key_ptr)
                return tls_ctxes[(int) (*key_ptr)].ptr;
            if (tls_ctxes[(int) (*key_ptr)].key
                == (pthread_key_t) ACL_TLS_OUT_OF_INDEXES)
            {
        
                tls_ctxes[(int) (*key_ptr)].key = *key_ptr;
                return tls_ctxes[(int) (*key_ptr)].ptr;
            }
            acl_msg_warn("%s(%d): tls_ctxes[%d].key(%d)!= key(%d)",
                         myname, __LINE__, (int) (*key_ptr),
                         (int) tls_ctxes[(int) (*key_ptr)].key, (int) (*key_ptr));
            return NULL;
        }
    
        /* 找出一个空位 */
        for (i = 0; i < acl_tls_ctx_max; i++) {
        
            if (tls_ctxes[i].key == (pthread_key_t) ACL_TLS_OUT_OF_INDEXES)
                break;
        }
    
        /* 如果没有空位可用则返回空并置错误标志位 */
        if (i == acl_tls_ctx_max) {
        
            acl_msg_error("%s(%d): no space for tls key", myname, __LINE__);
            *key_ptr = (pthread_key_t) ACL_TLS_OUT_OF_INDEXES;
            acl_set_error(ENOMEM);
            return NULL;
        }
    
        /* 为新分配的键初始化线程局部数据对象 */
        tls_ctxes[i].key = (pthread_key_t) i;
        tls_ctxes[i].free_fn = NULL;
        tls_ctxes[i].ptr = NULL;
        *key_ptr = (pthread_key_t) i;
        return NULL;
    }
    
    int acl_pthread_tls_set(pthread_key_t key, void *ptr,
                            void (*free_fn)(void *))
    {
        
        const char *myname = "acl_pthread_tls_set";
        TLS_CTX *tls_ctxes;
    
        if ((int) key < 0 || (int) key >= acl_tls_ctx_max) {
        
            acl_msg_error("%s(%d): key(%d) invalid",
                          myname, __LINE__, (int) key);
            acl_set_error(EINVAL);
            return EINVAL;
        }
    
        if (__tls_ctx_key == (pthread_key_t) ACL_TLS_OUT_OF_INDEXES) {
        
            acl_msg_error("%s(%d): __tls_ctx_key invalid, tid(%lu)",
                          myname, __LINE__, (unsigned long) pthread_self());
            acl_set_error(ENOMEM);
            return ENOMEM;
        }
        tls_ctxes = (TLS_CTX*) pthread_getspecific(__tls_ctx_key);
        if (tls_ctxes == NULL) {
        
            acl_msg_error("%s(%d): __tls_ctx_key(%d) no exist",
                          myname, __LINE__, (int) __tls_ctx_key);
            return -1;
        }
        if (tls_ctxes[(int) key].key != key) {
        
            acl_msg_error("%s(%d): key(%d) invalid",
                          myname, __LINE__, (int) key);
            acl_set_error(EINVAL);
            return EINVAL;
        }
        /* 如果该键值存在旧数据则首先需要释放掉旧数据 */
        if (tls_ctxes[(int) key].ptr != NULL && tls_ctxes[(int) key].free_fn != NULL)
            tls_ctxes[(int) key].free_fn(tls_ctxes[(int) key].ptr);
    
        tls_ctxes[(int) key].free_fn = free_fn;
        tls_ctxes[(int) key].ptr = ptr;
        return 0;
    }
    
    int acl_pthread_tls_del(pthread_key_t key)
    {
        
        const char *myname = "acl_pthread_tls_del";
        TLS_CTX *tls_ctxes;
    
        if ((int) key < 0 || (int) key >= acl_tls_ctx_max) {
        
            acl_msg_error("%s(%d): key(%d) invalid",
                          myname, __LINE__, (int) key);
            acl_set_error(EINVAL);
            return EINVAL;
        }
    
        if (__tls_ctx_key == (pthread_key_t) ACL_TLS_OUT_OF_INDEXES) {
        
            acl_msg_error("%s(%d): __tls_ctx_key invalid, tid(%lu)",
                          myname, __LINE__, (unsigned long) pthread_self());
            acl_set_error(ENOMEM);
            return ENOMEM;
        }
    
        tls_ctxes = (TLS_CTX*) pthread_getspecific(__tls_ctx_key);
        if (tls_ctxes == NULL) {
        
            acl_msg_error("%s(%d): __tls_ctx_key(%d) no exist",
                          myname, __LINE__, (int) __tls_ctx_key);
            return -1;
        }
    
        if (tls_ctxes[(int) key].key != key) {
        
            acl_msg_error("%s(%d): key(%d) invalid",
                          myname, __LINE__, (int) key);
            acl_set_error(EINVAL);
            return EINVAL;
        }
    
        tls_ctxes[(int) key].free_fn = NULL;
        tls_ctxes[(int) key].ptr = NULL;
        tls_ctxes[(int) key].key = (pthread_key_t) ACL_TLS_OUT_OF_INDEXES;
        return 0;
    }

使用如下：

#include "lib_acl.h"
    #include <stdlib.h>
    #include <stdio.h>
    
    // 每个线程退出时回调此函数来释放线程局部变量的动态分配的内存
    static void destructor(void *arg)
    {
        
        acl_myfree(arg);
    }
    
    static void *thread_fn(void *arg)
    {
        
        static acl_pthread_key_t key = -1;
        char *ptr;
    
        // 获得本线程对应 key 键值的线程局部变量
        ptr = acl_pthread_tls_get(&key);
        if (ptr == NULL) {
        
            // 如果为空，则生成一个
            ptr = acl_mymalloc(256);
            // 设置对应 key 键值的线程局部变量
            acl_pthread_tls_set(key, ptr, destructor);
        }
    
        /* do something */
    
        return (NULL);
    }
    
    static void run(void)
    {
        
         int   i, n = 10; 
         acl_pthread_t tids[10]; 
    
        // 创建新的线程
        for (i = 0; i < n; i++) {
         
            acl_pthread_create(&tids[i], NULL, thread_fn, NULL); 
        } 
    
        // 等待所有线程退出
        for (i = 0; i < n; i++) {
         
            acl_pthread_join(&tids[i], NULL); 
        } 
    }
    
    int main(int argc, char *argv[])
    {
        
        acl_init();  // 初始化ACL库
        // 打印当前可用的线程局部变量索引键的个数
        printf(">>>current tls max: %d/n", acl_pthread_tls_get_max());
        // 设置可用的线程局部变量索引键的限制个数
        acl_pthread_tls_set_max(10240);
    
        run();
        return (0);
    }

[linux]: https://blog.csdn.net/zhizhengguan/article/details/110661088
[20201221143326203.png]: /images/20221120/9c9070886a324b7cb60580e468e64ad9.png