執行緒私有資料(Thread-specific data，TSD)：儲存和查詢與某個執行緒相關資料的一種機制。

1、在程序內的所有執行緒都共享相同的地址空間，即意味著任何宣告為靜態或外部變數，或在程序堆宣告的變數，       都可以被程序內所有的執行緒讀寫。 2、一個執行緒真正擁有的唯一私有儲存是處理器暫存器，棧在“主人”故意暴露給其他執行緒時也是共享的。 3、有時需要提供執行緒私有資料：可以跨多個函式訪問(全域性)；僅在某個執行緒有效(私有)(即線上程裡面是全域性）。例如：errno。

程序中的所有執行緒都可以訪問程序的整個地址空間，除非使用暫存器（一個執行緒真正擁有的唯一私有儲存是處理器暫存器），執行緒沒有辦法阻止其它執行緒訪問它的資料，執行緒私有資料也不例外，但是管理執行緒私有資料的函式可以提高執行緒間的資料獨立性。

程序內的所有執行緒共享程序的資料空間，因此全域性變數為所有執行緒所共有。但有時執行緒也需要儲存自己的私有資料，這時可以建立執行緒私有資料（Thread-specific Date）TSD來解決。線上程內部，私有資料可以被各個函式訪問，但對其他執行緒是遮蔽的。例如我們常見的變數errno，它返回標準的出錯資訊。它顯然不能是一個區域性變數，幾乎每個函式都應該可以呼叫它；但它又不能是一個全域性變數。（即線上程裡面是全域性變數）

建立執行緒私有資料就是為了執行緒內部各個函式可以很容易的傳遞資料資訊，因此要使執行緒外的函式不能訪問這些資料，而執行緒內的函式使用這些資料就像執行緒內的全域性變數一樣，這些資料在一個執行緒內部是全域性的，一般用執行緒私有資料的地址作為執行緒內各個函式訪問該資料的入口。

 執行緒私有資料採用了一種被稱為一鍵多值的技術，即一個鍵對應多個數值。訪問資料時都是通過鍵值來訪問，好像是對一個變數進行訪問，其實是在訪問不同的資料。使用執行緒私有資料時，首先要為每個執行緒私有資料建立一個相關聯的鍵。在各個執行緒內部，都使用這個公用的鍵來指代執行緒資料，但是在不同的執行緒中，這個鍵代表的資料是不同的。操作執行緒私有資料的函式主要有4個：pthread_key_create（建立一個鍵），pthread_setspecific（為一個鍵設定執行緒私有資料），pthread_getspecific（從一個鍵讀取執行緒私有資料），pthread_key_delete（刪除一個鍵）。

建立一個鍵：

int pthread_key_create(pthread_key_t *keyp, void (*destructor)(void *));//返回值：若成功則返回0，否則返回錯誤編號 在分配(malloc)執行緒私有資料之前，需要建立和執行緒私有資料相關聯的鍵(key),這個鍵的功能是獲得對執行緒私有資料的訪問權。
如果建立一個執行緒私有資料鍵，必須保證pthread_key_create對於每個Pthread_key_t變數僅僅被呼叫一次，因為如果一個鍵被建立兩次，其實是在建立兩個不同的鍵，第二個鍵將覆蓋第一個鍵，第一個鍵以及任何執行緒可能為其關聯的執行緒私有資料值將丟失。
建立新鍵時，每個執行緒的私有資料地址設為NULL。

注意：建立的鍵存放在keyp指向的記憶體單元，這個鍵可以被程序中的所有執行緒使用，但每個執行緒把這個鍵與不同的執行緒私有資料地址進行關聯。

除了建立鍵以外，pthread_key_create可以選擇為該鍵關聯解構函式，當執行緒退出時，如果執行緒私有資料地址被置為非NULL值，那麼解構函式就會被呼叫。

注意：解構函式引數為退出執行緒的私有資料的地址。如果私有資料的地址為NULL，就說明沒有解構函式與鍵關聯即不需要呼叫該解構函式。

當執行緒呼叫pthread_exit或者執行緒執行返回，正常退出時，解構函式就會被呼叫，但是如果執行緒呼叫了exit、_exit、Exit函式或者abort或者其它非正常退出時，就不會呼叫解構函式。

執行緒通常使用malloc為執行緒私有資料分配空間，解構函式通常釋放已分配的執行緒私有資料的記憶體。

執行緒可以為執行緒私有資料分配多個鍵，每個鍵都可以有一個解構函式與它關聯。各個鍵的解構函式可以互不相同，當然它們也可以使用相同的解構函式。

執行緒退出時，執行緒私有資料的解構函式將按照作業系統實現定義的順序被呼叫。解構函式可能呼叫另外一個函式，而該函式可能建立新的執行緒私有資料而且把這個執行緒私有資料和當前的鍵關聯起來。當所有的解構函式都呼叫完成以後，系統會檢查是否有非NULL的執行緒私有資料值與鍵關聯，如果有的話，再次呼叫解構函式，這個過程一直重複到執行緒所有的鍵都為NULL值執行緒私有資料，或者已經做了PTHREAD_DESTRUCTOR_ITERATIONS中定義的最大次數的嘗試。

取消鍵與執行緒私有資料之間的關聯：

int pthread_delete(pthread_key_t *keyp);//返回值：若成功則返回0，否則返回錯誤編號 注意呼叫pthread_delete不會啟用與鍵關聯的解構函式。刪除執行緒私有資料鍵的時候，不會影響任何執行緒對該鍵設定的執行緒私有資料值，甚至不影響呼叫執行緒當前鍵值，所以容易造成記憶體洩露（因為鍵不與私有資料關聯了，當執行緒正常退出的時候不會呼叫鍵的解構函式，最終導致執行緒的私有資料這塊記憶體沒有釋放）。使用已經刪除的私有資料鍵將導致未定義的行為。

 注意：對於每個pthread_key_t變數(即鍵)必須僅呼叫一次pthread_key_create。如果一個鍵建立兩次，其實是在建立不同的鍵，第二個鍵將覆蓋第一個，第一個鍵與任何執行緒可能為其設定的值將一起永遠的丟失。所以，pthread_key_create放在主函式中執行；或每個執行緒使用pthread_once來建立鍵。

執行緒私有資料與鍵關聯：

int pthread_setspecific(pthread_key_t key,const void *value);//返回值：若成功則返回0，否則返回錯誤編號
void* pthread_getspecific(pthread_key_t key);//返回值：執行緒私有資料地址；若沒有值與鍵關聯則返回NULL
如果沒有執行緒私有資料值與鍵關聯，pthread_getspecific鍵返回NULL，可以依據此來確定是否呼叫pthread_setspecific。

注意：兩個執行緒對自己的私有資料操作是互相不影響的。也就是說，雖然 key 是同名且全域性，但訪問的記憶體空間並不是相同的一個。key 就像是一個數據管理員，執行緒的私有資料只是到他那去註冊，讓它知道你這個資料的存在
示例程式碼： #include <stdio.h>
#include <pthread.h>
#include <stdlib.h>

typedef struct private_tag {
    pthread_t   thread_id;
    char        *string;
} private_t;

pthread_key_t identity_key;         /* Thread-specific data key */
pthread_mutex_t identity_key_mutex = PTHREAD_MUTEX_INITIALIZER;
long identity_key_counter = 0;


void identity_key_destructor (void *value)
{
    private_t *private = (private_t*)value;
    int status;

    printf ("thread \"%s\" exiting...\n", private->string);
    free (value);
    status = pthread_mutex_lock (&identity_key_mutex);
    if (status != 0)
        perror("pthread_mutex_lock");
    identity_key_counter--;
    if (identity_key_counter <= 0) {
        status = pthread_key_delete (identity_key);
        if (status != 0)
            perror("pthread_key_delete");
        printf ("key deleted...\n");
    }
    status = pthread_mutex_unlock (&identity_key_mutex);
    if (status != 0)
        perror("pthread_mutex_unlock");
}

void *identity_key_get (void)
{
    void *value;
    int status;

    value = pthread_getspecific (identity_key);
    if (value == NULL) {
        value = malloc (sizeof (private_t));
        if (value == NULL)
            perror ("malloc");
        status = pthread_setspecific (identity_key, (void*)value);
        if (status != 0)
            perror("pthread_setspecific");
    }
    return value;
}

void *thread_routine (void *arg)
{
    private_t *value;

    value = (private_t*)identity_key_get ();
    value->thread_id = pthread_self ();
    value->string = (char*)arg;
    printf ("thread \"%s\" starting...\n", value->string);
    sleep (2);
    return NULL;   
}

void main (int argc, char *argv[])
{
    pthread_t thread_1, thread_2;
    private_t *value;
    int status;

    status = pthread_key_create (&identity_key, identity_key_destructor);
    if (status != 0)
        perror("pthread_key_create");
    identity_key_counter = 3;
    value = (private_t*)identity_key_get ();
    value->thread_id = pthread_self ();
    value->string = "Main thread";
    status = pthread_create (&thread_1, NULL,thread_routine, "Thread 1");
    if (status != 0)
        perror("pthread_create");
    status = pthread_create (&thread_2, NULL,thread_routine, "Thread 2");
    if (status != 0)
        perror("pthread_create");
    pthread_exit (NULL);
}
執行結果：
[email protected]:~$ ./a.out
thread "Main thread" exiting...
thread "Thread 2" starting...
thread "Thread 1" starting...
thread "Thread 2" exiting...
thread "Thread 1" exiting...
key deleted...
[email protected]:~$

示例程式碼2：

#include <stdio.h>
#include <pthread.h>
#include <stdlib.h>

typedef struct tsd_tag{
        pthread_t thread_id;
        char *string;
}tsd_t;

pthread_key_t key;
pthread_once_t once = PTHREAD_ONCE_INIT;

void once_routine(void)
{
        int status;

        printf("Initializing key\n");
        status = pthread_key_create(&key, NULL);
        if(status != 0){
           perror("pthread_key_create");
        }
}

void *thread_routine(void *arg)
{
        int status;
        tsd_t *value = NULL;

        status = pthread_once(&once, once_routine);
        if(status != 0){
            perror("pthread_once");
        }

        value = (tsd_t *)malloc(sizeof(tsd_t));
        if(value == NULL){
            perror("malloc");
        }

        status = pthread_setspecific(key, (void *)value);
        if(status != 0){
           perror("pthread_setspecific");
        }

        printf("%s set tsd value at %p\n", (char *)arg, value);
        value->thread_id = pthread_self();
        value->string = (char *)arg;

        printf("%s starting......\n", (char *)arg);
        sleep(2);
        value = (tsd_t *)pthread_getspecific(key);
        if(value == NULL){
            printf("no thread-specific data value was associated \
                        with key\n");
            pthread_exit(NULL);
        }
        printf("%s done......\n", value->string);
}

int main(int argc, char **argv)
{
        pthread_t thread1, thread2;
        int status;

        status = pthread_create(&thread1, NULL, thread_routine, "thread 1");
        if(status != 0){
                perror("pthread_create");
        }

        status = pthread_create(&thread2, NULL, thread_routine, "thread 2");
        if(status != 0){
                perror("pthread_create");
        }

        pthread_exit(NULL);
}

執行結果：
[email protected]:~$ ./a.out
Initializing key
thread 2 set tsd value at 0x8fb7520
thread 2 starting......
thread 1 set tsd value at 0x8fb7530
thread 1 starting......
thread 2 done......
thread 1 done......

示例程式碼3：

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

pthread_key_t key;

struct test_struct {
    int i;
    float k;
};


void *child1 (void *arg)
{
    struct test_struct struct_data;

    struct_data.i = 10;
    struct_data.k = 3.1415;

    pthread_setspecific (key, &struct_data);
    printf ("結構體struct_data的地址為 0x%p\n", &(struct_data));
    printf ("child1 中 pthread_getspecific(key)返回的指標為:0x%p\n", (struct test_struct *)pthread_getspecific(key));

    printf ("利用 pthread_getspecific(key)列印 child1 執行緒中與key關聯的結構體中成員值:\nstruct_data.i:%d\nstruct_data.k: %f\n", ((struct test_struct *)pthread_getspecific (key))->i, ((struct test_struct *)pthread_getspecific(key))->k);

    printf ("------------------------------------------------------\n");
}

void *child2 (void *arg)
{
    int temp = 20;
    sleep (2);
    printf ("child2 中變數 temp 的地址為 0x%p\n",  &temp);
    pthread_setspecific (key, &temp);
    printf ("child2 中 pthread_getspecific(key)返回的指標為:0x%p\n", (int *)pthread_getspecific(key));
    printf ("利用 pthread_getspecific(key)列印 child2 執行緒中與key關聯的整型變數temp 值:%d\n", *((int *)pthread_getspecific(key)));
}

int main (void)
{
    pthread_t tid1, tid2;

    pthread_key_create (&key, NULL);

    pthread_create (&tid1, NULL, (void *)child1, NULL);
    pthread_create (&tid2, NULL, (void *)child2, NULL);
    pthread_join (tid1, NULL);
    pthread_join (tid2, NULL);

    pthread_key_delete (key);

    return (0);
}

執行結果：
[email protected]:~$ ./a.out  
結構體struct_data的地址為 0x0xb77db388  
child1 中 pthread_getspecific(key)返回的指標為:0x0xb77db388  
利用 pthread_getspecific(key)列印 child1 執行緒中與key關聯的結構體中成員值:  
struct_data.i:10  
struct_data.k: 3.141500  
------------------------------------------------------  
child2 中變數 temp 的地址為 0x0xb6fda38c  
child2 中 pthread_getspecific(key)返回的指標為:0x0xb6fda38c  
利用 pthread_getspecific(key)列印 child2 執行緒中與key關聯的整型變數temp 值:20