PHP 源码学习之线程安全

自打作用域上来说,C语言可以定义4栽不同的变量:全局变量,静态全局变量,局部变量,静态局部变量。

脚就自函数作用域的角度解析一下不比的变量,假设有变量声明非重名。

  • 全局变量,在函数外声明,例如,int gVar;。全局变量,所有函数共享,在旁地方出现这个变量名都是因这个变量

  • 静态全局变量(static sgVar),其实呢是兼备函数共享,但是这会发出编译器的限量,算是编译器提供的同等栽意义

  • 一部分变量(函数/块内的int var;),不共享,函数的一再执行着涉嫌的这变量都是互相独立的,他们只是重名的两样变量而曾

  • 局部静态变量(函数中之static int sVar;),本函数间共享,函数的各一样浅实践着涉及的此变量都是这个和一个变量

点几乎种植作用域都是起函数的角度来定义作用域的,可以满足所有我们针对单线程编程中变量的共享情况。
现在我们来分析一下几近线程的情。在多线程中,多个线程共享除函数调用栈之外的其余资源。
因此上面几乎种植作用域从概念来拘禁就改为了。

  • 全局变量,所有函数共享,因此所有的线程共享,不同线程中冒出的不比变量都是即刻与一个变量

  • 静态全局变量,所有函数共享,也是独具线程共享

  • 有变量,此函数的各次执行着涉嫌的这变量没有联络,因此,也是各个线程间也是未共享的

  • 静态局部变量,本函数间共享,函数的每次执行涉及的这变量都是和一个变量,因此,各个线程是共享的

一、缘起TSRM

于多线程系统被,进程保留着资源所有权的属性,而大多单冒出执行流是执行于经过遭到运作的线程。
如 Apache2 中的
worker,主控制过程生成多只分支进程,每个子进程中带有固定的线程数,各个线程独立地拍卖要。
同样,为了不以恳求到来时再生成线程,MinSpareThreads 和 MaxSpareThreads
设置了起码及最好多之空闲线程数; 而 MaxClients
设置了所有子进程被的线程总数。如果现有子进程中之线程总数不能够满足负荷,控制过程将派生新的子进程。

当 PHP 运行在苟达到接近的多线程服务器时,此时底 PHP
处在多线程的生命周期中。
在一定的日子外,一个历程空间被见面存在多单线程,同一进程中之基本上只线程公用模块初始化后的全局变量,
如果和 PHP 在 CLI
模式下一致运行脚本,则大多单线程会算计读写一些储存于经过内存空间的官资源(如在差不多个线程公用的模块初始化后的函数外会是较多之全局变量),

此时这些线程访问的内存地址空间相同,当一个线程修改时,会影响其他线程,这种共享会提高部分操作的快,
但是基本上独线程间便发出了于生之耦合,并且当多单线程并发时,就会出大的数一致性问题还是资源竞争等并发常见问题,
比如多次周转结果及单线程运行的结果莫等同。如果每个线程中对全局变量、静态变量只生读操作,而随便写操作,则这些个全局变量就是线程安全的,只是这种情形不绝现实。

也化解线程的面世问题,PHP 引入了 TSRM: 线程安全资源管理器(Thread Safe
Resource Manager)。 TRSM 的实现代码在 PHP 源码的 /TSRM
目录下,调用随处可见,通常,我们称为 TSRM 层。 一般的话,TSRM
层只会以叫指明要的时候才见面于编译时启用(比如,Apache2+worker
MPM,一个因线程的MPM), 因为 Win32 下之 Apache
来说,是因多线程的,所以这层在 Win32 下连被开启之。

二、TSRM的实现

经过保留着资源所有权的属性,线程做并发访问,PHP 中引入的 TSRM
层关注之是指向共享资源的访问,
这里的共享资源是线程之间共享的在让经过的内存空间的全局变量。 当 PHP
在单进程模式下时,一个变量被声称在外函数之外时,就成一个全局变量。

第一定义了之类几个老重要的全局变量(这里的全局变量是多线程共享的)。

/* The memory manager table */
static tsrm_tls_entry   **tsrm_tls_table=NULL;
static int              tsrm_tls_table_size;
static ts_rsrc_id       id_count;

/* The resource sizes table */
static tsrm_resource_type   *resource_types_table=NULL;
static int                  resource_types_table_size;

**tsrm_tls_table 的全拼 thread safe resource manager thread local
storage table,用来存放在各个线程的 tsrm_tls_entry 链表。

tsrm_tls_table_size 用来表示 **tsrm_tls_table 的大小。

id_count 作为全局变量资源的 id 生成器,是大局唯一且递增的。

*resource_types_table 用来存放在全局变量对应之资源。

resource_types_table_size 表示 *resource_types_table 的大小。

中涉嫌到片只基本点之数据结构 tsrm_tls_entry 和 tsrm_resource_type

typedef struct _tsrm_tls_entry tsrm_tls_entry;

struct _tsrm_tls_entry {
    void **storage;// 本节点的全局变量数组
    int count;// 本节点全局变量数
    THREAD_T thread_id;// 本节点对应的线程 ID
    tsrm_tls_entry *next;// 下一个节点的指针
};

typedef struct {
    size_t size;// 被定义的全局变量结构体的大小
    ts_allocate_ctor ctor;// 被定义的全局变量的构造方法指针
    ts_allocate_dtor dtor;// 被定义的全局变量的析构方法指针
    int done;
} tsrm_resource_type;

当新增一个全局变量时,id_count 会自增1(加上线程互斥锁)。然后根据全局变量需要的内存、构造函数、析构函数生成对应之资源tsrm_resource_type,存入 *resource_types_table,再因该资源,为每个线程的拥有tsrm_tls_entry节点添加其对应的全局变量。

发出了是大体的问询,下面通过精心分析 TSRM 环境的初始化和资源 ID
的分红来掌握这无异于完整的经过。

TSRM 环境的初始化

模块初始化阶段,在一一 SAPI main 函数中经调用 tsrm_startup 来初始化
TSRM
环境。tsrm_startup 函数会流传两独坏关键之参数,一个凡是 expected_threads,表示预期的线程数,
一个凡 expected_resources,表示预期的资源数。不同之 SAPI
有两样的初始化值,比如mod_php5,cgi 这些都是一个线程一个资源。

TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_level, char *debug_filename)
{
    /* code... */

    tsrm_tls_table_size = expected_threads; // SAPI 初始化时预计分配的线程数,一般都为1

    tsrm_tls_table = (tsrm_tls_entry **) calloc(tsrm_tls_table_size, sizeof(tsrm_tls_entry *));

    /* code... */

    id_count=0;

    resource_types_table_size = expected_resources; // SAPI 初始化时预先分配的资源表大小,一般也为1

    resource_types_table = (tsrm_resource_type *) calloc(resource_types_table_size, sizeof(tsrm_resource_type));

    /* code... */

    return 1;
}

简短出里面就的老三单关键的行事,初始化了 tsrm_tls_table
链表、resource_types_table 数组,以及
id_count。而就三独全局变量是富有线程共享的,实现了线程间的内存管理的一致性。

资源 ID 的分配

咱理解初始化一个全局变量时需要采用 ZEND_INIT_MODULE_GLOBALS
宏(下面的数组扩展的例子中会生证实),而那实际则是调用的
ts_allocate_id 函数在多线程环境下报名一个全局变量,然后回来分配的资源
ID。代码虽然较多,实际还是于清楚,下面附带注解进行验证:

TSRM_API ts_rsrc_id ts_allocate_id(ts_rsrc_id *rsrc_id, size_t size, ts_allocate_ctor ctor, ts_allocate_dtor dtor)
{
    int i;

    TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtaining a new resource id, %d bytes", size));

    // 加上多线程互斥锁
    tsrm_mutex_lock(tsmm_mutex);

    /* obtain a resource id */
    *rsrc_id = TSRM_SHUFFLE_RSRC_ID(id_count++); // 全局静态变量 id_count 加 1
    TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtained resource id %d", *rsrc_id));

    /* store the new resource type in the resource sizes table */
    // 因为 resource_types_table_size 是有初始值的(expected_resources),所以不一定每次都要扩充内存
    if (resource_types_table_size < id_count) {
        resource_types_table = (tsrm_resource_type *) realloc(resource_types_table, sizeof(tsrm_resource_type)*id_count);
        if (!resource_types_table) {
            tsrm_mutex_unlock(tsmm_mutex);
            TSRM_ERROR((TSRM_ERROR_LEVEL_ERROR, "Unable to allocate storage for resource"));
            *rsrc_id = 0;
            return 0;
        }
        resource_types_table_size = id_count;
    }

    // 将全局变量结构体的大小、构造函数和析构函数都存入 tsrm_resource_type 的数组 resource_types_table 中
    resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].size = size;
    resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].ctor = ctor;
    resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].dtor = dtor;
    resource_types_table[TSRM_UNSHUFFLE_RSRC_ID(*rsrc_id)].done = 0;

    /* enlarge the arrays for the already active threads */
    // PHP内核会接着遍历所有线程为每一个线程的 tsrm_tls_entry
    for (i=0; i<tsrm_tls_table_size; i++) {
        tsrm_tls_entry *p = tsrm_tls_table[i];

        while (p) {
            if (p->count < id_count) {
                int j;

                p->storage = (void *) realloc(p->storage, sizeof(void *)*id_count);
                for (j=p->count; j<id_count; j++) {
                    // 在该线程中为全局变量分配需要的内存空间
                    p->storage[j] = (void *) malloc(resource_types_table[j].size);
                    if (resource_types_table[j].ctor) {
                        // 最后对 p->storage[j] 地址存放的全局变量进行初始化,
                        // 这里 ts_allocate_ctor 函数的第二个参数不知道为什么预留,整个项目中实际都未用到过,对比PHP7发现第二个参数也的确已经移除了
                        resource_types_table[j].ctor(p->storage[j], &p->storage);
                    }
                }
                p->count = id_count;
            }
            p = p->next;
        }
    }

    // 取消线程互斥锁
    tsrm_mutex_unlock(tsmm_mutex);

    TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Successfully allocated new resource id %d", *rsrc_id));
    return *rsrc_id;
}

当通过 ts_allocate_id 函数分配全局资源 ID 时,PHP
内核会先加上互斥锁,确保生成的资源 ID
的唯一,这里锁之用意是于时刻维度将面世的情变成串行,因为起的向问题即是日的问题。当加锁以后,id_count
自增,生成一个资源 ID,生成资源 ID 后,就见面被当下资源 ID
分配存储的职位, 每一个资源且见面储存在 resource_types_table
中,当一个新的资源被分配时,就会创一个 tsrm_resource_type。 所有
tsrm_resource_type 因数组的法子做
tsrm_resource_table,其下标就是是资源的 ID。 其实我们可拿
tsrm_resource_table 看做一个 HASH 表,key 是资源 ID,value 是
tsrm_resource_type 结构(任何一个数组都足以当做一个 HASH
表,如果反复组的key 值有义的语)。

当分配了资源 ID 后,PHP 内核会接着遍历所有线程为各级一个线程的
tsrm_tls_entry 分配者线程全局变量需要之内存空间。
这里每个线程全局变量的分寸在分级的调用处指定(也便是全局变量结构体的深浅)。最后对地方存放的全局变量进行初始化。为者我写了一样张图与证

图片 1

落得图被还有一个困惑的地方,tsrm_tls_table 的要素是安添加的,链表是哪些落实的。我们管此问题先行留着,后面会讨论。

列一样次等的 ts_allocate_id 调用,PHP
内核都见面遍历所有线程并为各级一个线程分配相应资源,
如果这个操作是于PHP生命周期的恳求处理等进行,岂不是会再调用?

PHP 考虑了这种情景,ts_allocate_id 的调用在模块初始化时便调用了。

TSRM 启动后,在模块初始化过程遭到见面遍历每个扩展的模块初始化方法,
扩展的全局变量在壮大的实现代码开头声明,在 MINIT 方法中初始化。
其当初始化时见面通知 TSRM
申请之全局变量以及大小,这里所谓的通告操作实际就是前面所说之
ts_allocate_id 函数。 TSRM
在内存池中分配并报,然后以资源ID返回给扩展。

全局变量的采取

为专业的数组扩展为例,首先会见声明时扩大的全局变量。

ZEND_DECLARE_MODULE_GLOBALS(array)

然后以模块初始化时见面调用全局变量初始化宏初始化
array,比如分配内存空间操作。

static void php_array_init_globals(zend_array_globals *array_globals)
{
    memset(array_globals, 0, sizeof(zend_array_globals));
}

/* code... */

PHP_MINIT_FUNCTION(array) /* {{{ */
{
    ZEND_INIT_MODULE_GLOBALS(array, php_array_init_globals, NULL);
    /* code... */
}

此地的声明与初始化操作都是分别ZTS和非ZTS。

#ifdef ZTS

#define ZEND_DECLARE_MODULE_GLOBALS(module_name)                            \
    ts_rsrc_id module_name##_globals_id;

#define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)   \
    ts_allocate_id(&module_name##_globals_id, sizeof(zend_##module_name##_globals), (ts_allocate_ctor) globals_ctor, (ts_allocate_dtor) globals_dtor);

#else

#define ZEND_DECLARE_MODULE_GLOBALS(module_name)                            \
    zend_##module_name##_globals module_name##_globals;

#define ZEND_INIT_MODULE_GLOBALS(module_name, globals_ctor, globals_dtor)   \
    globals_ctor(&module_name##_globals);

#endif

对此非ZTS的气象,直接声明变量,初始化变量;对于ZTS情况,PHP内核会添加TSRM,不再是声称全局变量,而是用ts_rsrc_id代替,初始化时也不再是初始化变量,而是调用ts_allocate_id函数在多线程环境受到受当下以此模块申请一个全局变量并回到资源ID。其中,资源ID变量名由模块名加global_id组成。

要是只要调用当前扩张的全局变量,则使:ARRAYG(v),这个特大的概念:

#ifdef ZTS
#define ARRAYG(v) TSRMG(array_globals_id, zend_array_globals *, v)
#else
#define ARRAYG(v) (array_globals.v)
#endif

比方是非ZTS则直接调用全局变量的属性字段,如果是ZTS,则需要经过TSRMG获取变量。

TSRMG的定义:

#define TSRMG(id, type, element) (((type) (*((void ***) tsrm_ls))[TSRM_UNSHUFFLE_RSRC_ID(id)])->element)

失去丢就同堆放括号,TSRMG宏的意就是是自tsrm_ls中本资源ID获取全局变量,并回对应变量的性能字段。

这就是说现在底问题是其一 tsrm_ls 从哪里来之?

tsrm_ls 的初始化

tsrm_ls 通过 ts_resource(0) 初始化。展开实际最后调用的是 ts_resource_ex(0,NULL) 。下面将 ts_resource_ex 一些宏展开,线程以 pthread 为例。

#define THREAD_HASH_OF(thr,ts)  (unsigned long)thr%(unsigned long)ts

static MUTEX_T tsmm_mutex;

void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id)
{
    THREAD_T thread_id;
    int hash_value;
    tsrm_tls_entry *thread_resources;

    // tsrm_tls_table 在 tsrm_startup 已初始化完毕
    if(tsrm_tls_table) {
        // 初始化时 th_id = NULL;
        if (!th_id) {

            //第一次为空 还未执行过 pthread_setspecific 所以 thread_resources 指针为空
            thread_resources = pthread_getspecific(tls_key);

            if(thread_resources){
                TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count);
            }

            thread_id = pthread_self();
        } else {
            thread_id = *th_id;
        }
    }
    // 上锁
    pthread_mutex_lock(tsmm_mutex);

    // 直接取余,将其值作为数组下标,将不同的线程散列分布在 tsrm_tls_table 中
    hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size);
    // 在 SAPI 调用 tsrm_startup 之后,tsrm_tls_table_size = expected_threads
    thread_resources = tsrm_tls_table[hash_value];

    if (!thread_resources) {
        // 如果还没,则新分配。
        allocate_new_resource(&tsrm_tls_table[hash_value], thread_id);
        // 分配完毕之后再执行到下面的 else 区间
        return ts_resource_ex(id, &thread_id);
    } else {
         do {
            // 沿着链表逐个匹配
            if (thread_resources->thread_id == thread_id) {
                break;
            }
            if (thread_resources->next) {
                thread_resources = thread_resources->next;
            } else {
                // 链表的尽头仍然没有找到,则新分配,接到链表的末尾
                allocate_new_resource(&thread_resources->next, thread_id);
                return ts_resource_ex(id, &thread_id);
            }
         } while (thread_resources);
    }

    TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count);

    // 解锁
    pthread_mutex_unlock(tsmm_mutex);

}

而 allocate_new_resource 则是吧新的线程在对应之链表中分配内存,并且将有所的全局变量都投入到其 storage 指针数组中。

static void allocate_new_resource(tsrm_tls_entry **thread_resources_ptr, THREAD_T thread_id)
{
    int i;

    (*thread_resources_ptr) = (tsrm_tls_entry *) malloc(sizeof(tsrm_tls_entry));
    (*thread_resources_ptr)->storage = (void **) malloc(sizeof(void *)*id_count);
    (*thread_resources_ptr)->count = id_count;
    (*thread_resources_ptr)->thread_id = thread_id;
    (*thread_resources_ptr)->next = NULL;

    // 设置线程本地存储变量。在这里设置之后,再到 ts_resource_ex 里取
    pthread_setspecific(*thread_resources_ptr);

    if (tsrm_new_thread_begin_handler) {
        tsrm_new_thread_begin_handler(thread_id, &((*thread_resources_ptr)->storage));
    }

    for (i=0; i<id_count; i++) {
        if (resource_types_table[i].done) {
            (*thread_resources_ptr)->storage[i] = NULL;
        } else {
            // 为新增的 tsrm_tls_entry 节点添加 resource_types_table 的资源
            (*thread_resources_ptr)->storage[i] = (void *) malloc(resource_types_table[i].size);
            if (resource_types_table[i].ctor) {
                resource_types_table[i].ctor((*thread_resources_ptr)->storage[i], &(*thread_resources_ptr)->storage);
            }
        }
    }

    if (tsrm_new_thread_end_handler) {
        tsrm_new_thread_end_handler(thread_id, &((*thread_resources_ptr)->storage));
    }

    pthread_mutex_unlock(tsmm_mutex);
}

上面有一个知识点,Thread Local Storage
,现在产生雷同全局变量 tls_key,所有线程都得采用它们,改变它的价。
表面上看起就是一个全局变量,所有线程都可以用它们,而它们的价在列一个线程中而是单独存储的。这就是线程本地存储的意思。
那么什么样落实线程本地存储吗?

需要联合 tsrm_startupts_resource_exallocate_new_resource 函数并下放以注释一起举例说明:

// 以 pthread 为例
// 1. 首先定义了 tls_key 全局变量
static pthread_key_t tls_key;

// 2. 然后在 tsrm_startup 调用 pthread_key_create() 来创建该变量
pthread_key_create( &tls_key, 0 ); 

// 3. 在 allocate_new_resource 中通过 tsrm_tls_set 将 *thread_resources_ptr 指针变量存入了全局变量 tls_key 中
tsrm_tls_set(*thread_resources_ptr);// 展开之后为 pthread_setspecific(*thread_resources_ptr);

// 4. 在 ts_resource_ex 中通过 tsrm_tls_get() 获取在该线程中设置的 *thread_resources_ptr 
//    多线程并发操作时,相互不会影响。
thread_resources = tsrm_tls_get();

于知道了 tsrm_tls_table 数组和内链表的始建之后,再拘留 ts_resource_ex 函数惨遭调用的之返回宏

#define TSRM_SAFE_RETURN_RSRC(array, offset, range)     \
    if (offset==0) {                                    \
        return &array;                                  \
    } else {                                            \
        return array[TSRM_UNSHUFFLE_RSRC_ID(offset)];   \
    }

纵然是根据传入 tsrm_tls_entry 和 storage 的数组下标 offset ,然后返回该全局变量在拖欠线程的 storage数组中的地方。到这里虽清楚了在多线程中得到全局变量宏 TSRMG 宏定义了。

骨子里就在我们形容扩展的时段会常用:

#define TSRMLS_D void ***tsrm_ls   /* 不带逗号,一般是唯一参数的时候,定义时用 */
#define TSRMLS_DC , TSRMLS_D       /* 也是定义时用,不过参数前面有其他参数,所以需要个逗号 */
#define TSRMLS_C tsrm_ls
#define TSRMLS_CC , TSRMLS_C

NOTICE 写扩展的早晚恐怕多校友还分不清楚到底用哪一个,通过宏展开我们可以看到,他们分别是带逗号和免带来逗号,以及说明及调用,那么英语中“D”就是意味着:Define,而
后面的”C”是 Comma,逗号,前面的”C”就是Call。

上述也ZTS模式下之定义,非ZTS模式下其定义全部为空。

参考资料

  • 究竟什么是TSRMLS_CC?-
    54chen
  • 深入研讨PHP及Zend
    Engine的线程安全模型

 

本文来源:https://github.com/zhoumengkang/tipi/blob/master/book/chapt08/08-03-zend-thread-safe-in-php.markdown?spm=5176.100239.blogcont60787.4.Mvv5xg&file=08-03-zend-thread-safe-in-php.markdown

相关文章