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 時，那麼當修改進程的優先級時，該進程中繼承這個優先級並且還沒有改變其優先級的所 有線程也將會跟著改變優先級（也就是剛才那句話部正確的原因）。

下面寫個程序測試一下：

#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 函數。

#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。