PHP-TSRM-Thread-Sicherheitsmanager-Quellcode-Analyse

Beim Anzeigen von PHP-Quellcode oder beim Entwickeln von PHP-Erweiterungen werden an der Position von Funktionsparametern eine große Anzahl von TSRMLS_-Makros angezeigt. Diese Makros werden von Zend für den Thread-Sicherheitsmechanismus (Zend Thread „Safety“, kurz ZTS) bereitgestellt Thread-Sicherheit gewährleisten ist eine Lösung, die verhindert, dass der PHP-Interpreter in Form eines Moduls in einer Multithread-Umgebung geladen und ausgeführt wird, was zu Lesefehlern in einigen internen öffentlichen Ressourcen führt.

Wann müssen Sie die TSRM-Umgebung verwenden? In diesem Fall müssen Sie eine Thread-sichere Version von PHP verwenden, d. h. TSRM aktivieren. Unter Linux geben Sie an, ob TSRM aktiviert werden soll Beim Kompilieren von PHP wird eine Thread-sichere Version und eine nicht Thread-sichere Version von PHP bereitgestellt.

So implementieren Sie TSRM in PHP

In einer normalen Multithread-Umgebung werden Mutex-Sperren zu öffentlichen Ressourcen hinzugefügt, PHP wählt jedoch keine Sperre, da Sperren zu Leistungseinbußen führen können. Die Lösung von PHP besteht darin, alle öffentlichen Ressourcen des aktuellen PHP-Kernels für jeden Thread zu kopieren, ohne sich gegenseitig zu beeinflussen, und jeder Thread betreibt seine eigenen öffentlichen Ressourcen.

Was sind öffentliche Ressourcen?

Es handelt sich um eine Vielzahl von Strukturstrukturdefinitionen

TSRM-Datenstruktur

tsrm_tls_entry Thread-Struktur, jeder Thread Es gibt eine Kopie dieser Struktur

Feldbeschreibung

typedef struct _tsrm_tls_entry tsrm_tls_entry;
struct _tsrm_tls_entry {
    void **storage;   
    int count;
    THREAD_T thread_id;
    tsrm_tls_entry *next;
}
static tsrm_tls_entry   **tsrm_tls_table = NULL //线程指针表头指针
static int  tsrm_tls_table_size;  //当前线程结构体数量

void **storage ：资源指针、就是指向自己的公共资源内存区
int count : 资源数、就是 PHP内核 + 扩展模块 共注册了多少公共资源
THREAD_T thread_id ： 线程id
tsrm_tls_entry *next：指向下一个线程指针，因为当前每一个线程指针都存在一个线程指针表里（类似于hash表），这个next可以理解成是hash冲突链式解决法.
tsrm_resource_type 公共资源类型结构体、注册了多少公共资源就有多少个该结构体

Feldbeschreibung

typedef struct {
    size_t size;
    ts_allocate_ctor ctor;
    ts_allocate_dtor dtor;
    int done; 
} tsrm_resource_type;
static tsrm_resource_type   *resource_types_table=NULL;  //公共资源类型表头指针
static int  resource_types_table_size; //当前公共资源类型数量

Globale Ressourcen-ID

size_t size : 资源大小
ts_allocate_ctor ctor: 构造函数指针、在给每一个线程创建该资源的时候会调用一下当前ctor指针
ts_allocate_dtor dtor : 析构函数指针、释放该资源的时候会调用一下当前dtor指针
int done : 资源是否已经销毁 0:正常 1:已销毁

Was ist eine globale Ressourcen-ID

typedef int ts_rsrc_id;
static ts_rsrc_id   id_count;

TSRM generiert für jede Ressource eine eindeutige ID, wenn öffentliche Ressourcen registriert werden. Sie müssen die entsprechende Ressourcen-ID angeben, wenn Sie die Ressource in Zukunft abrufen.

Warum brauchen wir eine globale Ressourcen-ID?

Weil jeder unserer Threads alle aktuell registrierten öffentlichen Ressourcen kopiert, also ein malloc() und ein großes Array. Diese Ressourcen-ID ist Der Index des Arrays, dh um die entsprechende Ressource zu erhalten, müssen Sie die ID der entsprechenden Ressource angeben.

Es ist leicht zu verstehen:

Weil TSRM es jedem Thread ermöglicht, auf seinen eigenen Stapel öffentlicher Ressourcen (Array) zu verweisen, und Sie möchten in diesem Stapel öffentlicher Ressourcen finden, was Sie suchen Wenn es sich nicht um diese Thread-sichere Version handelt, werden diese öffentlichen Ressourcen nicht in einem Stapel zusammengefasst und können direkt über den entsprechenden Namen abgerufen werden.

Ungefährer Ausführungsprozess

Initialisieren Sie während der Kernel-Initialisierung TSRM, registrieren Sie öffentliche Ressourcen, die am Kernel beteiligt sind, und registrieren Sie öffentliche Ressourcen, die an externen Erweiterungen beteiligt sind.

Der entsprechende Thread ruft die Eingabeposition der PHP-Interpreterfunktion auf, um die öffentlichen Ressourcendaten des aktuellen Threads zu initialisieren.

Wenn Sie die öffentliche Ressource benötigen, erhalten Sie sie einfach über die entsprechende Ressourcen-ID.

TSRM-Initialisierungsstrukturdiagramm

TSRM-Quelldateipfad

TSRM umfasst die Hauptfunktion

/php-5.3.27/TSRM/TSRM.c
/php-5.3.27/TSRM/TSRM.h

initialisiert tsrm

registriert öffentliche Ressourcen

tsrm_startup()

ruft alle öffentlichen Ressourcen ab, registriert sie und initialisiert sie, wenn dies der Fall ist nicht vorhanden. Rückgabe- und Speicherzeiger

ts_allocate_id()

Rufen Sie die entsprechende Ressource ab, indem Sie die Ressourcen-ID angeben

#define TSRMLS_FETCH() void ***tsrm_ls = (void ***) ts_resource_ex(0, NULL)

Initialisieren Sie den aktuellen Thread und kopieren Sie die vorhandenen öffentlichen Ressourcendaten zum Speicherzeiger

#define ts_resource(id)    ts_resource_ex(id, NULL)

TSRM Einige gängige Makrodefinitionen

allocate_new_resource()

Sie können sehen, dass dieser Satz von TSRM-Makros vorhanden ist, wenn TSRM aktiviert ist und ZTS wahr ist werden häufig definiert. Diese Makros in der Funktionsparameterliste werden in der Erweiterung durch den void-Zeiger ***tsrm_ls ersetzt. Tatsächlich ruft der aktuelle Thread diese Funktion auf und übergibt die öffentliche Ressourcenbereichsadresse &storage** des Threads Stellen Sie sicher, dass der interne Ausführungsprozess der Funktion die öffentlichen Ressourcen des entsprechenden Threads genau abruft

#ifdef ZTS
#define TSRMLS_D   void ***tsrm_ls
#define TSRMLS_DC  , TSRMLS_D
#define TSRMLS_C   tsrm_ls
#define TSRMLS_CC  , TSRMLS_C
#else
#define TSRMLS_D   void
#define TSRMLS_DC
#define TSRMLS_C
#define TSRMLS_CC
#endif

TSRM Die ungefähre Methode zum Aufrufen der Funktion

ruft

TSRMLS_FETCH() auf und ersetzt void ** *tsrm_ls

Ausführung

Ersetzen

->  test(int a  TSRMLS_CC) -> test_1(int b TSRMLS_CC)

TSRM So geben Sie frei

->  test(int a  ,tsrm_ls) -> test_1(int b ,tsrm_ls)

Wie oben erwähnt, Apaches Worker Beim Multiprozess-Multithreading wird ein Prozess gestartet. Mehrere Threads rufen den PHP-Interpreter auf. Wenn jeder Thread endet, werden die vom aktuellen Thread erstellten Ressourcendaten nicht sofort zerstört (da der Thread möglicherweise sofort wieder verwendet wird). Es ist nicht erforderlich, alle dem Thread entsprechenden Ressourcen neu zu initialisieren. Die öffentlichen Ressourcendaten können direkt verwendet werden. Wenn der Prozess jedoch zu Ende geht, werden alle Threads durchlaufen und alle Threads und entsprechenden Ressourcendaten freigegeben.

Quellcode-Kommentare

tsrm_startup-Funktionsbeschreibung

Im Allgemeinen wird diese Funktion aufgerufen, wenn der PHP-Kernel initialisiert wird. Um Speicher zu sparen, ist der Standardwert a Thread-Nummer und a Die Anzahl der Ressourcentypen, die später erweitert werden, wenn nicht genug

TSRM_API int tsrm_startup(int expected_threads, int expected_resources, int debug_level, char *debug_filename)
{
    //省略...
    
    //默认线程数
    tsrm_tls_table_size = expected_threads;
    //创建tsrm_tls_entry指针数组
    tsrm_tls_table = (tsrm_tls_entry **) calloc(tsrm_tls_table_size, sizeof(tsrm_tls_entry *));
    //省略...
    
    //全局资源唯一ID初始化
    id_count=0;
    //默认资源类型数
    resource_types_table_size = expected_resources;
    //省略...
    
    //创建tsrm_resource_type结构体数组
    resource_types_table = (tsrm_resource_type *) calloc(resource_types_table_size, sizeof(tsrm_resource_type));
    //省略...
    
    return 1;
}

ts_allocate_id-Funktionsbeschreibung

Diese Funktion muss beim Registrieren und Erstellen öffentlicher Ressourcendaten aufgerufen werden Normalerweise wird diese Funktion nur in einer Thread-Umgebung aufgerufen und führt kontinuierlich zu Ralloc und Malloc

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;
    //省略...
    //生成当前资源的唯一id
    *rsrc_id = TSRM_SHUFFLE_RSRCidD(id_count++);
    TSRM_ERROR((TSRM_ERROR_LEVEL_CORE, "Obtained resource id %d", *rsrc_id));
    
    //判断当前资源类型表是否小于当前资源数
    //如果小于则对资源类型表进行扩容
    if (resource_types_table_size < id_count) {
        resource_types_table = (tsrm_resource_type *) realloc(resource_types_table, sizeof(tsrm_resource_type)*id_count);
        //省略...
        resource_types_table_size = id_count;
    }
    //赋值公共资源的大小，构造函数和析构函数指针
    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;
    
    //遍历说有的线程结构体，把当前创建的资源数据赋给storage指向的内存空间
    for (i=0; i<tsrm_tls_table_size; i++) {
        tsrm_tls_entry *p = tsrm_tls_table[i];
        
        //第一种情况
        //p有可能是null，因为还没有调用 TSRMLS_FETCH() 初始化线程结构体指针
        //所以 resource_types_table 就先暂时保存该资源的 size，之后等初始化
        //线程结构体指针的时候，会自动在创建该公共资源的内存空间，并赋值storage
        
        //第二种情况
        //已初始化对应的线程结构体指针，那么就直接根据当前新创建的资源id号对
        //p->storage进行扩容，因为资源id都是递增增加的,并根据当前资源的size
        //malloc创建具体的资源内存空间，创建完成之后回调一下ctor
        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) {
                        resource_types_table[j].ctor(p->storage[j], &p->storage);
                    }
                }
                
                //id_count每次+1 ， 实际上就是我们公共资源的总数量
                p->count = id_count;
            }
            //指向下一个线程结构体指针
            p = p->next;
        }
    }
    //省略...
    //返回刚才id_count++
    return *rsrc_id;
}

TSRMLS_FETCH() - > ts_resource_ex-Funktionsbeschreibung

allocate_new_resource-Funktionsbeschreibung

TSRM_API void *ts_resource_ex(ts_rsrc_id id, THREAD_T *th_id)
{
    THREAD_T thread_id;
    int hash_value;
    tsrm_tls_entry *thread_resources;
    //省略...
    
    if(tsrm_tls_table) {
        //获取当前线程ID
        if (!th_id) {
            //省略...
            thread_id = tsrm_thread_id();
        } else {
            thread_id = *th_id;
        }
    TSRM_ERROR((TSRM_ERROR_LEVEL_INFO, "Fetching resource id %d for thread %ld", id, (long) thread_id));
    tsrm_mutex_lock(tsmm_mutex);
    
    #define THREAD_HASH_OF(thr,ts)  (unsigned long)thr%(unsigned long)ts
    //通过线程id和当前初始化线程数大小进行取模运算，算出当前线程指针位置因为
    //当前线程指针都存在tsrm_tls_table表里，如果当前位置已经存在一个线程指针
    //则 tsrm_tls_table->next 实际上就是一个hash冲突链式解决方法.
    hash_value = THREAD_HASH_OF(thread_id, tsrm_tls_table_size);
    thread_resources = tsrm_tls_table[hash_value];
    //如果不存在去创建当前线程，并将之前调用ts_allocate_id注册创建的那些公共资源
    //全部copy过来.
    if (!thread_resources) {
        allocate_new_resource(&tsrm_tls_table[hash_value], thread_id);
        return ts_resource_ex(id, &thread_id);
    } else {
         do {
            //判断线程id是否相等
            if (thread_resources->thread_id == thread_id) {
                break;
            }
            //如果不等于则next
            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);
    }
    //找到或创建完当前线程之后，返回当前线程公共资源区&storage指针 
    //如果指定资源id的话则返回 storage[id] 指针
    TSRM_SAFE_RETURN_RSRC(thread_resources->storage, id, thread_resources->count);
}

Erweiterte TSRM-Nutzung

我们在开发扩展的时候也要按照线程安全版本去开发，通过 ZTS 宏判断当前 PHP 是否线程安全版本.

扩展里公共资源定义：

//定义公共资源数据，替换之后就是一个zend_模块名字的结构体
ZEND_BEGIN_MODULE_GLOBALS(module_name)
int id;
char name;
ZEND_END_MODULE_GLOBALS(module_name)
//对应的宏定义
#define ZEND_BEGIN_MODULE_GLOBALS(module_name)
    typedef struct _zend_##module_name##_globals {
#define ZEND_END_MODULE_GLOBALS(module_name)
} zend_##module_name##_globals;
//替换后
typedef struct _zend_module_name_globals {
   int id;
   char name;
} zend_module_name_globals;

扩展里的资源id定义

#ifdef ZTS
  #define ZEND_DECLARE_MODULE_GLOBALS(module_name)              
          ts_rsrc_id module_name##_globals_id;
#else
#define ZEND_DECLARE_MODULE_GLOBALS(module_name)                               
          zend_##module_name##_globals module_name##_globals;
#endif

（1） 线程安全版本：则自动声明全局资源唯一id，因为每个线程都会通过当前的id去storage指向内存区获取资源数据
（2）非线程安全版本：则自动声明当前结构体变量，每次通过变量名获取资源就好了，因为不存在其他线程争抢的情况

扩展里获取公共资源数据

#ifdef ZTS
    #define MODULE_G(v) TSRMG(xx_globals_id, zend_xx_globals *, v)
#else
    #define MODULE_G(v) (xx_globals.v)
#endif

如上每次获取资源全部通过自己定义的MODULE_G()宏获取，如果是线程安全则通过对应的TSRM管理器获取当前线程指定的资源id数据，如果不是则直接通过资源变量名字获取即可

扩展里初始化公共资源

//一般初始化公共资源数据,都会在扩展的MINIT函数执行
//如果是ZTS则ts_allocate_id调用之.
PHP_MINIT_FUNCTION(myextension){
    #ifdef ZTS
       ts_allocate_id(&xx_globals_id，sizeof(zend_module_name_globals),ctor,dtor)
    #endif
}

结束

上面介绍的就是PHP-TSRM线程安全管理器的实现，了解TSRM之后，无论是看内核源码还是开发PHP扩展都有很大的好处，因为内核和扩展里面充斥着大量的TSRM_宏定义.

相关阅读：

PHP中的TSRM及其宏的使用(线程安全管理)

php cgi与fpm关系

PHP CGI FastCGI php-fpm 解惑

Das obige ist der detaillierte Inhalt vonPHP-TSRM-Thread-Sicherheitsmanager-Quellcode-Analyse. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!