linux網路編程之posix 線程（二）：線程的屬性和 線程特定資料 Thread-specific Data

一、posix 線程屬性

POSIX 線程庫定義了線程屬性對象 pthread_attr_t ，它封裝了線程的建立者可以訪問和修改的線程屬性。主要包括如下屬性：

1. 範圍（scope）

2. 棧尺寸（stack size）

3. 棧地址（stack address）

4. 優先順序（priority）

5. 分離的狀態（detached state）

6. 調度策略和參數（scheduling policy and parameters）

 線程屬性對象可以與一個線程或多個線程相關聯。當使用線程屬性對象時，它是對線程和線程組行為的配置。使用屬性對象的所有線程都將具有由屬性對象所定義的所有屬 性。雖然它們共用屬性對象，但它們維護各自獨立的線程 ID 和寄存器。

 線程可以在兩種競爭域內競爭資源：

1. 進程域（process scope）：與同一進程內的其他線程

2. 系統域（system scope）：與系統中的所有線程

範圍屬性描述特定線程將與哪些線程競爭資源。一個具有系統域的線程將與整個系 統中所有具有系統域的線程按照優先順序競爭處理器資源，進行調度。

分離線程是指不需要和進程中其他線程同步的線程。也就是說，沒有線程會等待分離 線程退出系統。因此，一旦該線程退出，它的資源（如線程 ID）可以立即被重用。

線程的布局嵌入在進程的布局中。進程有程式碼片段、資料區段和棧段，而線程與進程中的 其他線程共用程式碼片段和資料區段，每個線程都有自己的棧段，這個棧段在進程地址空間的棧 段中進行分配。線程棧的尺寸線上程建立時設定。如果在建立時沒有設定，那麼系統將會 指定一個預設值，預設值的大小依賴於具體的系統。

POSIX 線程屬性對象中可設定的線程屬性及其含義參見下表：

函數	屬性	含義
int pthread_attr_setdetachstate (pthread_attr_t* attr ,int detachstate)	detachstate	detachstate 屬性控制一個線程是否 是可分離的
int pthread_attr_setguardsize (pthread_attr_t* attr ,size_t guardsize)	guardsize	guardsize 屬性設定新建立線程棧的溢出 保護區大小
int pthread_attr_setinheritsched (pthread_attr_t* attr, int inheritsched)	inheritsched	inheritsched 決定怎樣設定新建立 線程的調度屬性
int pthread_attr_setschedparam (pthread_attr_t* attr , const struct sched_param* restrict param)	param	param 用來設定新建立線程的優先順序
int pthread_attr_setschedpolicy (pthread_attr_t* attr, int policy)	policy	Policy 用來設定先建立線程的調度 策略
int pthread_attr_setscope (pthread_attr_t* attr , int contentionscope)	contentionscope	contentionscope 用於設定新建立線 程的範圍
int pthread_attr_setstack (pthread_attr_t* attr, void* stackader, size_t stacksize)	stackader stacksize	兩者共同決定了線程棧的基地址 以及堆棧的最小尺寸（以位元組為 單位）
int pthread_attr_setstackaddr(pthread _attr_t* attr, void*stackader)	stackader	stackader 決定了新建立線程的棧的基地址

int pthread_attr_setstacksize(pthread_attr_t* attr, size_t stacksize)    
stacksize 決定了新建立線程的棧的最小尺寸

進程的調度策略和優先順序屬於主線程，換句話說就是設定進程的調度策略和優先順序只 會影響主線程的調度策略和優先順序，而不會改變對等線程的調度策略和優先順序（注這句話不完全正確）。每個對等線程可以擁有它自己的獨立於主線程的調度策略和優先順序。

在 Linux 系統中，進程有三種調度策略：SCHED_FIFO、SCHED_RR 和 SCHED_OTHER，線程也不例外，也具有這三種策略。

在 pthread 庫中，提供了一個函數，用來設定被建立的線程的調度屬性：是從建立者線 程繼承調度屬性（調度策略和優先順序），還是從屬性對象設定調度屬性。該函數就是：

int pthread_attr_setinheritsched (pthread_attr_t *   attr, int    inherit) 其中，inherit 的值為下列值中的其一：

enum

{

PTHREAD_INHERIT_SCHED, //線程調度屬性從建立者線程繼承

 PTHREAD_EXPLICIT_SCHED //線程調度屬性設定為 attr 設定的屬性

};

如果在建立新的線程時，調用該函數將參數設定為 PTHREAD_INHERIT_SCHED 時，那麼當修改進程的優先順序時，該進程中繼承這個優先順序並且還沒有改變其優先順序的所 有線程也將會跟著改變優先順序（也就是剛才那句話部正確的原因）。

下面寫個程式測試一下：

 C++ Code 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

#include <unistd.h> #include <sys/types.h> #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <errno.h> #include <string.h> #define ERR_EXIT(m) \         do \         { \                 perror(m); \                 exit(EXIT_FAILURE); \         } while(0) int main(void) {     pthread_attr_t attr;     pthread_attr_init(&attr);     int state;     pthread_attr_getdetachstate(&attr, &state);     if (state == PTHREAD_CREATE_JOINABLE)         printf("detachstate:PTHREAD_CREATE_JOINABLE\n");     else if (state == PTHREAD_CREATE_DETACHED)         printf("detachstate:PTHREAD_CREATE_DETACHED");     size_t size;     pthread_attr_getstacksize(&attr, &size);     printf("stacksize:%d\n", size);     pthread_attr_getguardsize(&attr, &size);     printf("guardsize:%d\n", size);     int scope;     pthread_attr_getscope(&attr, &scope);     if (scope == PTHREAD_SCOPE_PROCESS)         printf("scope:PTHREAD_SCOPE_PROCESS\n");     if (scope == PTHREAD_SCOPE_SYSTEM)         printf("scope:PTHREAD_SCOPE_SYSTEM\n");     int policy;     pthread_attr_getschedpolicy(&attr, &policy);     if (policy == SCHED_FIFO)         printf("policy:SCHED_FIFO\n");     else if (policy == SCHED_RR)         printf("policy:SCHED_RR\n");     else if (policy == SCHED_OTHER)         printf("policy:SCHED_OTHER\n");     int inheritsched;     pthread_attr_getinheritsched(&attr, &inheritsched);     if (inheritsched == PTHREAD_INHERIT_SCHED)         printf("inheritsched:PTHREAD_INHERIT_SCHED\n");     else if (inheritsched == PTHREAD_EXPLICIT_SCHED)         printf("inheritsched:PTHREAD_EXPLICIT_SCHED\n");     struct sched_param param;     pthread_attr_getschedparam(&attr, &param);     printf("sched_priority:%d\n", param.sched_priority);     pthread_attr_destroy(&attr);     return 0; }

在調用各個函數設定線程屬性對象的屬性時需要先調用pthread_attr_init 初始化這個對象，最後調用pthread_attr_destroy 銷毀這個對象。

simba@ubuntu:~/Documents/code/linux_programming/UNP/pthread$ ./pthread_attr 
detachstate:PTHREAD_CREATE_JOINABLE
stacksize:8388608
guardsize:4096
scope:PTHREAD_SCOPE_SYSTEM
policy:SCHED_OTHER
inheritsched:PTHREAD_INHERIT_SCHED
sched_priority:0

二、線程特定資料 Thread-specific Data

在單線程程式中，我們經常要用到"全域變數"以實現多個函數間共用資料。
在多線程環境下，由於資料空間是共用的，因此全域變數也為所有線程所共有。 
但有時應用程式設計中有必要提供線程私人的全域變數，僅在某個線程中有效，但卻可以跨多個函數訪問。
POSIX線程庫通過維護一定的資料結構來解決這個問題，這個些資料稱為（Thread-specific Data，或 TSD）。

相關函數如下：

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

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

int pthread_once(pthread_once_t *once_control, void (*init_routine)(void));
pthread_once_t once_control = PTHREAD_ONCE_INIT;

當調用pthread_key_create 後會產生一個所有線程都可見的線程特定資料（TSD）的pthread_key_t 值，調用pthread_setspecific 後會將每個線程的特定資料與pthread_key_t 綁定起來，雖然只有一個pthread_key_t，但每個線程的特定資料是獨立的記憶體空間，當線程退出時會執行destructor
函數。

 C++ Code 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69

#include <unistd.h> #include <sys/types.h> #include <pthread.h> #include <stdlib.h> #include <stdio.h> #include <errno.h> #include <string.h> #define ERR_EXIT(m) \         do \         { \                 perror(m); \                 exit(EXIT_FAILURE); \         } while(0) typedef struct tsd {     pthread_t tid;     char *str; } tsd_t; pthread_key_t key_tsd; pthread_once_t once_control = PTHREAD_ONCE_INIT; void destroy_routine(void *value) {     printf("destory ...\n");     free(value); } void once_routine(void) {     pthread_key_create(&key_tsd, destroy_routine);     printf("key init ...\n"); } void *thread_routine(void *arg) {     pthread_once(&once_control, once_routine);     tsd_t *value = (tsd_t *)malloc(sizeof(tsd_t));     value->tid = pthread_self();     value->str = (char *)arg;     pthread_setspecific(key_tsd, value);     printf("%s setspecific ptr=%p\n", (char *)arg, value);     value = pthread_getspecific(key_tsd);     printf("tid=0x%x str=%s ptr=%p\n", (int)value->tid, value->str, value);     sleep(2);     value = pthread_getspecific(key_tsd);     printf("tid=0x%x str=%s ptr=%p\n", (int)value->tid, value->str, value);     return NULL; } int main(void) {     //pthread_key_create(&key_tsd, destroy_routine);     pthread_t tid1;     pthread_t tid2;     pthread_create(&tid1, NULL, thread_routine, "thread1");     pthread_create(&tid2, NULL, thread_routine, "thread2");     pthread_join(tid1, NULL);     pthread_join(tid2, NULL);     pthread_key_delete(key_tsd);     return 0; }

主線程建立了兩個線程然後join 等待他們退出；給每個線程的執行函數都是thread_routine，thread_routine 中調用了pthread_once，此函數表示如果當第一個線程調用它時會執行once_routine，然後從once_routine返回即pthread_once 返回，而接下去的其他線程調用它時將不再執行once_routine，此舉是為了只調用pthread_key_create 一次，即產生一個pthread_key_t
值。

在thread_routine 函數中自訂了線程特定資料的類型，對於不同的線程來說TSD的內容不同，假設線程1在第一次列印完進入睡眠的時候，線程2也開始執行並調用pthread_setspecific 綁定線程2的TSD 和key_t，此時線程1調用pthread_getspecific 返回key_t 綁定的TSD指標，仍然是線程1的TSD指標，即雖然key_t 只有一個，但每個線程都有自己的TSD。

simba@ubuntu:~/Documents/code/linux_programming/UNP/pthread$ ./pthread_tsd 
key init ...
thread2 setspecific ptr=0xb6400468
tid=0xb6d90b40 str=thread2 ptr=0xb6400468
thread1 setspecific ptr=0xb6200468
tid=0xb7591b40 str=thread1 ptr=0xb6200468
tid=0xb7591b40 str=thread1 ptr=0xb6200468
destory ...
tid=0xb6d90b40 str=thread2 ptr=0xb6400468
destory ...

其中tid 是線程的id，str 是傳遞給thread_routine 的參數，可以看到有兩個不同的ptr。

參考：

《UNP》

《爐邊夜話--多核多線程雜談》