2. 程式人生 > >執行緒特定資料TSD總結

執行緒特定資料TSD總結

阿新 • • 發佈：2019-01-07

一、執行緒的本質

Linux執行緒又稱輕量程序(LWP),也就說執行緒本質是用程序之間共享使用者空間模擬實現的。

二、執行緒模型的引入

執行緒模型引入是為了資料共享,為什麼又引入執行緒私有資料?有時候想讓基於程序的介面適應多執行緒環境，這時候就需要為每個執行緒維護一份私有資料了，最典型的就是errno了。

在維護每個執行緒的私有資料的時候，我們可能會想到分配一個儲存執行緒資料的陣列，用執行緒的ID作為陣列的索引來實現訪問。
1. 系統生成的執行緒ID不能保證是一個小而連續的整數
2. 用陣列實現的時候容易出現越界讀寫的情況
鑑於這兩個問題，我們可以藉助執行緒的私有資料(TSD)來解決這個問題。

三、執行緒特定資料

執行緒私有資料(Thread Specific Data)，是儲存和查詢與某個執行緒相關的資料的一種機制。把這種資料稱為執行緒私有資料或執行緒特定資料的原因是，希望每個執行緒可以獨立地訪問資料副本，從而不需要考慮多執行緒同步問題。

提示：程序中的所有執行緒都可以訪問程序的整個地址空間。除了使用暫存器以外(一個執行緒真正擁有的唯一私有儲存是處理器的暫存器)，執行緒沒有辦法阻止其他執行緒訪問它的資料，執行緒私有資料也不例外。雖然底層的實現部分並不能阻止這種訪問能力，但管理執行緒私有資料的函式可以提高執行緒間的資料獨立性。

四、關鍵函式說明

  • int pthread_key_create(pthread_key_t *keyp,void (*destructor)(void *));


    返回值：若成功則返回0，否則返回錯誤編號
    功能：建立的鍵存放在keyp指向的記憶體單元，這個鍵可以被程序中的所有執行緒使用，但每個執行緒把這個鍵與不同的執行緒私有資料地址進行關聯。
    說明：

    1. 建立一個執行緒私有資料鍵，必須保證對於每個Pthread_key_t變數僅僅被呼叫一次，因為如果一個鍵被建立兩次，其實是在建立兩個不同的鍵。第二個鍵將覆蓋第一個鍵，第一個鍵以及任何執行緒可能與其關聯的執行緒私有資料值將丟失。解決這種競爭的辦法是使用pthread_once。

      pthread_once_t initflag = PTHREAD_ONCE_INIT;
      int pthread_once(pthread_once_t *initflag, void (*initfn)(void));


      返回值：若成功則返回0，否則返回錯誤編號
      說明：initflag必須是一個非本地變數（即全域性變數或靜態變數），而且必須初始化為PTHREAD_ONCE_INIT。

    2. 當執行緒呼叫pthread_exit或者執行緒執行返回，正常退出時，如果私有資料不為空且註冊了解構函式，解構函式就會被呼叫，但如果執行緒呼叫了exit、_exit、_Exit、abort或出現其他非正常的退出時就不會呼叫解構函式注1 。

    3. 執行緒可以為執行緒私有資料分配多個鍵注2，每個鍵都可以有一個解構函式與它關聯。各個鍵的解構函式可以互不相同，當然它們也可以使用相同的解構函式。
    4. 執行緒退出時，執行緒私有資料的解構函式將按照作業系統實現中定義的順序被呼叫。解構函式可能會呼叫另一個函式，該函式可能會建立新的執行緒私有資料而且把這個資料與當前的鍵關聯起來。當所有的解構函式都呼叫完成以後，系統會檢查是否還有非null的執行緒私有資料值與鍵關聯，如果有的話，再次呼叫解構函式。這個過程會一直重複直到執行緒所有的鍵都為null值執行緒私有資料，或者已經做了最大次數的嘗試注3。
    5. 建立新鍵時，每個執行緒的資料地址設為NULL。

  • int pthread_key_delete(pthread_key_t *keyp);
    返回值：若成功則返回0，否則返回錯誤編號
    功能：取消鍵與執行緒私有資料值之間的關聯關係。
    說明：

    1. 呼叫pthread_delete不會啟用與鍵關聯的解構函式，容易造成記憶體洩露。要釋放任何與鍵對應的執行緒私有資料值的記憶體空間，需要在應用程式中採取額外的步驟。當刪除執行緒私有資料鍵的時候，不會影響任何執行緒對該鍵設定的執行緒私有資料值，甚至不影響呼叫執行緒當前鍵值。建議最後才刪除執行緒私有資料鍵，尤其當一些執行緒仍然持有該鍵的值時,就更不該釋放該鍵。使用已經刪除的私有資料鍵將導致未定義的行為。

五、刨根問底啥原理

執行緒私有資料實現的主要思想，如圖所示
TSD
系統內部為每個程序維護了兩種資料，pthread_key_struct結構體陣列和pthread結構體：
1. pthread_key_struct結構的“標誌”指示這個資料元素是否正在使用，當然在剛開始時所有的標誌初始化為“不在使用”；
2. pthread結構體中有一部分內容是我們稱之為pkey陣列的一個128個元素的指標陣列；
3. 在分配執行緒私有資料之前需要呼叫pthread_key_create建立與該資料相關聯的健。系統搜尋pthread_key_struct結構陣列，找出第一個“不在使用”的元素，並把該元素的索引（0~127)稱為“鍵”，返回給呼叫執行緒的正是這個索引。這個鍵可以被程序中的所有執行緒使用，每個執行緒把這個鍵與不同的執行緒私有資料地址進行關聯(個人愚見：此處的關聯指的就是使用相同的索引)。雖然索引值相同，但是由於各個執行緒pkey陣列的起始地址不同，結果導致每個執行緒根據相同的索引取得的值不同(該值就是存放的私有資料)。

六、私有資料使用示例

/* 
 * TSD(Thread Specific Data)使用步驟說明
 * 執行環境：SlackwareLinux 64bit
 */

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

//1、建立一個型別為 pthread_key_t 型別的變數
pthread_key_t key;

void destructor(void *arg)
{
    //arg即為儲存的執行緒資料
    printf("destructor executed in thread %lx, param = %lx\n", pthread_self(), arg);
}

void * child1(void *arg)
{
    pthread_t tid = pthread_self();
    printf("thread1 %lx entering\n", tid);

    //3、進行執行緒資料儲存。
    //param1為前面宣告的 pthread_key_t key,
    //param2為要儲存的資料, void*型別說明可以儲存任何型別的資料
    pthread_setspecific(key, (void *)tid);

    sleep(2); //讓出cpu

    //4、取出所儲存的執行緒資料。
    //param為前面提到的 pthread_key_t key
    //如果沒有執行緒私有資料值與鍵關聯，pthread_getspecific將返回一個空指標，可以據此來確定是否需要呼叫pthread_setspecific。
    printf("thread1 %lx returned %lx\n", tid, pthread_getspecific(key));
}

void *child2(void *arg)
{
    pthread_t tid = pthread_self();
    printf("thread2 %lx entering\n", tid);
    pthread_setspecific(key, (void *)tid);
    sleep(1);
    printf("thread2 %lx returned %lx\n", tid, pthread_getspecific(key));
}

int main(int argc, char *argv[])
{
    pthread_t tid1, tid2;

    printf("main thread %lx entering\n", pthread_self());

    //2、把key與不同的執行緒私有資料地址進行關聯
    //第一個引數就是步驟1中宣告的key的地址;
    //第二個引數是一個清理執行緒儲存的函式，不是動態申請的該函式指標可以設成 NULL;
    pthread_key_create(&key, destructor);

    pthread_create(&tid1, NULL, child1, NULL);
    pthread_create(&tid2, NULL, child2, NULL);

    pthread_join(tid1, NULL);
    pthread_join(tid2, NULL);

    //5、解除key與執行緒私有資料地址的關聯
    pthread_key_delete(key);
    printf("main thread %lx returned\n", pthread_self());

    return 0;
}

執行結果

[email protected]:/scratchbox/test/lidonghai# ./a.out
main thread b77336c0 entering
thread1 b7732b90 entering
thread2 b6f32b90 entering
thread2 b6f32b90 returned b6f32b90
destructor executed in thread b6f32b90, param = b6f32b90
thread1 b7732b90 returned b7732b90
destructor executed in thread b7732b90, param = b7732b90
main thread b77336c0 returned
/*
 *  三個執行緒：主執行緒,th1,th2各自有自己的私有資料區域
 */

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

static pthread_key_t str_key;  //建立一個型別為 pthread_key_t 型別的變數
static pthread_once_t str_alloc_key_once = PTHREAD_ONCE_INIT; //define a static variable that only be allocated once
static void str_alloc_key();
static void str_alloc_destroy_accu(void* accu);

char* str_accumulate(const char* s)
{    
    char* accu;
    pthread_once(&str_alloc_key_once,str_alloc_key);      //str_alloc_key()這個函式只調用一次
    accu = (char*)pthread_getspecific(str_key);           //取得該執行緒對應的關鍵字所關聯的私有資料空間首址
    if(accu==NULL){                                       //每個新剛建立的執行緒這個值一定是NULL（沒有指向任何已分配的資料空間）

    accu=malloc(1024);                             
        if(!accu)    return NULL;
        accu[0] = 0;

        pthread_setspecific(str_key,(void*)accu);//設定該執行緒對應的關鍵字關聯的私有資料空間
        printf("Thread %lx: allocating buffer at %p\n",pthread_self(),accu);
    }

    strcat(accu,s);

    return accu;
}

static void str_alloc_key()
{    
    pthread_key_create(&str_key,str_alloc_destroy_accu);//建立關鍵字及其對應的記憶體釋放函式，當程序建立關鍵字後，這個關鍵字是NULL。
    printf("Thread %lx: allocated key %d\n",pthread_self(),str_key);
}

static void str_alloc_destroy_accu(void* accu)
{    
    printf("Thread %lx: freeing buffer at %p\n",pthread_self(),accu);
    free(accu);
}

//執行緒入口函式
void* process(void *arg)
{    
    char* res;
    res=str_accumulate("Result of ");
    if(strcmp((char*)arg,"first")==0)
        sleep(3);
    res=str_accumulate((char*)arg);
    res=str_accumulate(" thread");
    printf("Thread %lx: \"%s\"\n",pthread_self(),res);
    return NULL;
}

//主執行緒函式
int main(int argc,char* argv[])
{    char* res;
    pthread_t th1,th2;
    res=str_accumulate("Result of ");
    pthread_create(&th1,NULL,process,(void*)"first");
    pthread_create(&th2,NULL,process,(void*)"second");
    res=str_accumulate("initial thread");
    printf("Thread %lx: \"%s\"\n",pthread_self(),res);
    pthread_join(th1,NULL);
    pthread_join(th2,NULL);
    pthread_exit(0);
}

執行結果

[[email protected]10h57 c]# ./pthread_private_data
Thread b7fdd6c0 : allocated key 0
Thread b7fdd6c0: allocating buffer at 0x911c008
Thread b7fdd6c0: "Result of initial thread"
Thread b7fdcb90: allocating buffer at 0x911c938
Thread b75dbb90: allocating buffer at 0x911cd40
Thread b75dbb90: "Resule of second thread"
Thread b75dbb90: freeing buffer at 0x911cd40
Thread b7fdcb90: "Resule of first thread"
Thread b7fdcb90: freeing buffer at 0x911c938
Thread b7fdd6c0: freeing buffer at 0x911c008

七、參考文件

相關推薦

執行緒特定資料TSD總結

一、執行緒的本質 Linux執行緒又稱輕量程序(LWP),也就說執行緒本質是用程序之間共享使用者空間模擬實現的。 二、執行緒模型的引入 執行緒模型引入是為了資料共享,為什麼又引入執行緒私有資料?有時候想讓基於程序的介面適應多執行緒環境，這時候

執行緒特定資料TSD及其實現原理

引言：                 單執行緒C程式有兩類基本資料：區域性資料和全域性資料。對於多執行緒C程式，添加了第三類資料：執行緒特定資料         那麼為什麼要引入執行緒特定資料呢？試想如果你的一個執行緒裡面巢狀呼叫了很多函式，而你又想在這些函式之間使用一個

muduo_base程式碼剖析之執行緒特定資料的封裝ThreadLocal

執行緒特定資料 (執行緒內私有的全域性變數)來源 在單執行緒程式中，我們經常要用到“全域性變數”以實現多個函式間能共享資料 在多執行緒環境下，由於資料空間是共享的，因此全域性變數也為所有執行緒共享 但有時應用程式設計中有必要提供執行緒私有的全域性變數，僅在某個執行

32-執行緒控制——執行緒特定資料

1. 執行緒特定資料    執行緒特定資料(thread-specific-data)，也稱為執行緒私有資料(thread-private-data)，是儲存和查詢某個特定執行緒相關資料的一種機制(APUE的說法)。    之所以稱為執行緒私有資料，是因為讓每個

【Linux】執行緒特定資料

概述 執行緒特定資料（執行緒私有資料）是儲存和查詢某個特定執行緒相關資料的一種機制，使用這種機制是因為我們希望每個執行緒可以訪問它自己單獨的資料副本，而不需要擔心與其他執行緒的訪問同步問題。 執行緒的好處就在於促進了程序中資料和屬性的共享，那麼設計執行緒私有

Linux執行緒---執行緒特定資料

在單執行緒程式中。我們常常要用到”全域性變數”以實現多個函式間共享資料, 然而在多執行緒環境下。因為資料空間是共享的。因此全域性變數也為全部執行緒所共同擁有。但有時應用程式設計中有必要提供執行緒私有的全域性變數，僅在某個執行緒中有效，但卻能夠跨多個函式訪問。PO

執行緒特定資料（筆記）

概述：    執行緒特定資料，也稱為執行緒私有資料，是儲存和查詢某個特定資料相關資料的一種機制。    在單執行緒程式中，我們經常要用到“全域性變數”以實現多個函式間共享資料。    在多執行緒環境下，由於資料空間是共享的，因此全域性變數也為所有所有執行緒所共有。    但有

執行緒特定資料詳解

    執行緒特定資料，也被稱為執行緒私有資料，是一種儲存和查詢一個特定執行緒相關資料的機制。我們稱這個資料為執行緒特定或執行緒私有的原因，是因為每個執行緒訪問它自己獨立的資料拷貝，而不用擔心和其它執行緒的訪問的同步。     執行緒特定資料看似很複雜，其實我們可以把它理解

執行緒私有資料TSD——一鍵多值技術，執行緒同步中的互斥鎖和條件變數

一：執行緒私有資料： 執行緒是輕量級程序，程序在fork()之後，子程序不繼承父程序的鎖和警告，別的基本上都會繼承，而vfork()與fork()不同的地方在於vfork()之後的程序會共享父程序的地址空間，但是有了寫實複製（fork()之後的子程序也不會直接

Java多執行緒學習---------超詳細總結(java 多執行緒 同步 資料傳遞 )

平時專案中多執行緒的應用比較少，今天網上找了找相關的內容學習了下。看到下面的文章感覺比較好。 轉自：http://www.cnblogs.com/1020182600HENG/p/5939933.html 目錄 一擴充套件javalangThread類 二實現javalan

【多執行緒程式設計】執行緒私有資料（TSD）

Thread Specific Data（TSD） 執行緒私有資料，有什麼用呢？在多執行緒中，經常要用全域性變數來實現多個函式間的資料共享。由於資料空間是共享的，因此全域性變數也為所有程序共有。但有時應用程式設計中必要提供執行緒私有的全域性變數，這個變數被各個執行緒私有，但

多執行緒的學習與總結

單執行緒：        只有一個順序執行流        例如：單執行緒的程式如同只僱傭一個服務員的餐廳，他必須做完一件事情後才可以做下一件事情； 多執行緒：        可以

關於執行緒池 ExecutorService 的總結

一 、Java通過Executors提供四種執行緒池： newCachedThreadPool建立一個可快取執行緒池，如果執行緒池長度超過處理需要，可靈活回收空閒執行緒，若無可回收，則新建執行緒。 newFixedThreadPool 建立一個定長執行緒池，可控制執行緒最大併發數，超

多執行緒 取資料必須不重複的方案

最近一直在處理資料上傳和採集的問題, 因為寫在asp.net 裡面的web服務預設就是多執行緒的, 一個請求就是一個執行緒… 所以多執行緒之間為了不讀取重複的資料, 就成了問題. 資料必須嚴格不重複, 同樣的資料絕對不能處理2次… 多執行緒就更不能出現重複讀取的現象了. 自己現在

鎖機制——解決多執行緒的資料共享帶來的同步問題

“非執行緒安全”——多個執行緒對同一個物件中的例項變數進行併發訪問時發生，產生的後果就是“髒讀”，也就是取到的資料其實是被更改過的。 1、方法內的變數為執行緒安全的 方法內部的私有變數，則不存在“非執行緒安全”的問題，所得結果也就是“執行緒安全”的。 2、例項變數非執行緒安全 如果多個執行緒

多執行緒的資料共享

通過Runnable介面實現資料共享 下面通過模擬售票系統的一個小demo展示資料共享情況： 1.首先是一個實現了runnable介面的類，此類的成員變數票數ticketNum作為共享資料，因是成員變數，私有，所以此類不能new多個，只得通過new不同的Thread執行緒共用這一個物件。

C++11 多執行緒執行緒共享資料

共享資料的問題 這些在作業系統中都有詳細的介紹，可以回顧作業系統課程。。很典型的就是資料競爭問題。 互斥量保護資料 最原始的方式：使用std::mutex建立互斥量，使用成員lock()加鎖，使用成員unlock()解鎖。但是這種方式需要我們在每個函數出口都呼叫一次unloc

sysbench-1.0 多執行緒插入資料

在做MySQL oltp相關的測試需要進行資料準備，sysbench提供了多執行緒插入資料的方法，如下可以參考如下指令碼 sysbench ./lua/oltp_insert.lua \ --mysql-db=ashe \ --mysql-host=100.110.0.9 \ --m

有關多執行緒同步資料

 近期由於同步一批資料，資料數量三百多萬，一般的批量插入也太慢了，並且需要同時做更新和插入的操作，如果一般的做法先遍歷匹配，在分別進行更新和插入，則效率太低，後通過大神指點和上網查資料，終於使用merge into 語法完成了同步，雖然還是太慢，但是，也總是學到了些新的東西，現在我把思路和

Java多執行緒思維導圖總結

自己學習總結了一些思維導圖(持續更新中)，後面附有GitHub連結 ,分享給大家。https://github.com/panjianlong13/MindMapSummary             &n