- 論壇徽章:
- 0
|
4 線程的數(shù)據(jù)處理
和進程相比，線程的最大優(yōu)點之一是數(shù)據(jù)的共享性，各個進程共享父進程處沿襲的數(shù)據(jù)段，可以方便的獲得、修改數(shù)據(jù)。但這也給多線程編程帶來了許多問題。我們必須當(dāng)心有多個不同的進程訪問相同的變量。許多函數(shù)是不可重入的，即同時不能運行一個函數(shù)的多個拷貝（除非使用不同的數(shù)據(jù)段）。在函數(shù)中聲明的靜態(tài)變量常常帶來問題，函數(shù)的返回值也會有問題。因為如果返回的是函數(shù)內(nèi)部靜態(tài)聲明的空間的地址，則在一個線程調(diào)用該函數(shù)得到地址后使用該地址指向的數(shù)據(jù)時，別的線程可能調(diào)用此函數(shù)并修改了這一段數(shù)據(jù)。在進程中共享的變量必須用關(guān)鍵字volatile來定義，這是為了防止編譯器在優(yōu)化時（如gcc中使用-OX參數(shù)）改變它們的使用方式。為了保護變量，我們必須使用信號量、互斥等方法來保證我們對變量的正確使用。下面，我們就逐步介紹處理線程數(shù)據(jù)時的有關(guān)知識。
4.1 線程數(shù)據(jù)
在單線程的程序里，有兩種基本的數(shù)據(jù)：全局變量和局部變量。但在多線程程序里，還有第三種數(shù)據(jù)類型：線程數(shù)據(jù)（TSD: Thread-Specific Data）。它和全局變量很象，在線程內(nèi)部，各個函數(shù)可以象使用全局變量一樣調(diào)用它，但它對線程外部的其它線程是不可見的。這種數(shù)據(jù)的必要性是顯而易見的。例如我們常見的變量errno，它返回標準的出錯信息。它顯然不能是一個局部變量，幾乎每個函數(shù)都應(yīng)該可以調(diào)用它；但它又不能是一個全局變量，否則在A線程里輸出的很可能是B線程的出錯信息。要實現(xiàn)諸如此類的變量，我們就必須使用線程數(shù)據(jù)。我們?yōu)槊總�線程數(shù)據(jù)創(chuàng)建一個鍵，它和這個鍵相關(guān)聯(lián)，在各個線程里，都使用這個鍵來指代線程數(shù)據(jù)，但在不同的線程里，這個鍵代表的數(shù)據(jù)是不同的，在同一個線程里，它代表同樣的數(shù)據(jù)內(nèi)容。
和線程數(shù)據(jù)相關(guān)的函數(shù)主要有4個：創(chuàng)建一個鍵；為一個鍵指定線程數(shù)據(jù)；從一個鍵讀取線程數(shù)據(jù)；刪除鍵。
創(chuàng)建鍵的函數(shù)原型為：
extern int pthread_key_create __P ((pthread_key_t *__key,
void (*__destr_function) (void *)));
第一個參數(shù)為指向一個鍵值的指針，第二個參數(shù)指明了一個destructor函數(shù)，如果這個參數(shù)不為空，那么當(dāng)每個線程結(jié)束時，系統(tǒng)將調(diào)用這個函數(shù)來釋放綁定在這個鍵上的內(nèi)存塊。這個函數(shù)常和函數(shù)pthread_once ((pthread_once_t*once_control, void (*initroutine) (void)))一起使用，為了讓這個鍵只被創(chuàng)建一次。函數(shù)pthread_once聲明一個初始化函數(shù)，第一次調(diào)用pthread_once時它執(zhí)行這個函數(shù)，以后的調(diào)用將被它忽略。
在下面的例子中，我們創(chuàng)建一個鍵，并將它和某個數(shù)據(jù)相關(guān)聯(lián)。我們要定義一個函數(shù)createWindow，這個函數(shù)定義一個圖形窗口（數(shù)據(jù)類型為Fl_Window *，這是圖形界面開發(fā)工具FLTK中的數(shù)據(jù)類型）。由于各個線程都會調(diào)用這個函數(shù)，所以我們使用線程數(shù)據(jù)。
/* 聲明一個鍵*/
pthread_key_t myWinKey;
/* 函數(shù) createWindow */
void createWindow ( void ) {
Fl_Window * win;
static pthread_once_t once= PTHREAD_ONCE_INIT;
/* 調(diào)用函數(shù)createMyKey，創(chuàng)建鍵*/
pthread_once ( & once, createMyKey) ;
/*win指向一個新建立的窗口*/
win=new Fl_Window( 0, 0, 100, 100, "MyWindow");
/* 對此窗口作一些可能的設(shè)置工作，如大小、位置、名稱等*/
setWindow(win);
/* 將窗口指針值綁定在鍵myWinKey上*/
pthread_setpecific ( myWinKey, win);
}
/* 函數(shù) createMyKey，創(chuàng)建一個鍵，并指定了destructor */
void createMyKey ( void ) {
pthread_keycreate(&myWinKey, freeWinKey);
}
/* 函數(shù) freeWinKey，釋放空間*/
void freeWinKey ( Fl_Window * win){
delete win;
}
這樣，在不同的線程中調(diào)用函數(shù)createMyWin，都可以得到在線程內(nèi)部均可見的窗口變量，這個變量通過函數(shù)pthread_getspecific得到。在上面的例子中，我們已經(jīng)使用了函數(shù)pthread_setspecific來將線程數(shù)據(jù)和一個鍵綁定在一起。這兩個函數(shù)的原型如下：
extern int pthread_setspecific __P ((pthread_key_t __key,__const void *__pointer));
extern void *pthread_getspecific __P ((pthread_key_t __key));
這兩個函數(shù)的參數(shù)意義和使用方法是顯而易見的。要注意的是，用pthread_setspecific為一個鍵指定新的線程數(shù)據(jù)時，必須自己釋放原有的線程數(shù)據(jù)以回收空間。這個過程函數(shù)pthread_key_delete用來刪除一個鍵，這個鍵占用的內(nèi)存將被釋放，但同樣要注意的是，它只釋放鍵占用的內(nèi)存，并不釋放該鍵關(guān)聯(lián)的線程數(shù)據(jù)所占用的內(nèi)存資源，而且它也不會觸發(fā)函數(shù)pthread_key_create中定義的destructor函數(shù)。線程數(shù)據(jù)的釋放必須在釋放鍵之前完成。
4.2 互斥鎖
互斥鎖用來保證一段時間內(nèi)只有一個線程在執(zhí)行一段代碼。必要性顯而易見：假設(shè)各個線程向同一個文件順序?qū)懭霐?shù)據(jù)，最后得到的結(jié)果一定是災(zāi)難性的。
我們先看下面一段代碼。這是一個讀/寫程序，它們公用一個緩沖區(qū)，并且我們假定一個緩沖區(qū)只能保存一條信息。即緩沖區(qū)只有兩個狀態(tài)：有信息或沒有信息。
void reader_function ( void );
void writer_function ( void );
char buffer;
int buffer_has_item=0;
pthread_mutex_t mutex;
struct timespec delay;
void main ( void ){
pthread_t reader;
/* 定義延遲時間*/
delay.tv_sec = 2;
delay.tv_nec = 0;
/* 用默認屬性初始化一個互斥鎖對象*/
pthread_mutex_init (&mutex,NULL);
pthread_create(&reader, pthread_attr_default, (void *)&reader_function), NULL);
writer_function( );
}
void writer_function (void){
while(1){
/* 鎖定互斥鎖*/
pthread_mutex_lock (&mutex);
if (buffer_has_item==0){
buffer=make_new_item( );
buffer_has_item=1;
}
/* 打開互斥鎖*/
pthread_mutex_unlock(&mutex);
pthread_delay_np(&delay);
}
}
void reader_function(void){
while(1){
pthread_mutex_lock(&mutex);
if(buffer_has_item==1){
consume_item(buffer);
buffer_has_item=0;
}
pthread_mutex_unlock(&mutex);
pthread_delay_np(&delay);
}
}
這里聲明了互斥鎖變量mutex，結(jié)構(gòu)pthread_mutex_t為不公開的數(shù)據(jù)類型，其中包含一個系統(tǒng)分配的屬性對象。函數(shù)pthread_mutex_init用來生成一個互斥鎖。NULL參數(shù)表明使用默認屬性。如果需要聲明特定屬性的互斥鎖，須調(diào)用函數(shù)pthread_mutexattr_init。函數(shù)pthread_mutexattr_setpshared和函數(shù)pthread_mutexattr_settype用來設(shè)置互斥鎖屬性。前一個函數(shù)設(shè)置屬性pshared，它有兩個取值，PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用來不同進程中的線程同步，后者用于同步本進程的不同線程。在上面的例子中，我們使用的是默認屬性PTHREAD_PROCESS_ PRIVATE。后者用來設(shè)置互斥鎖類型，可選的類型有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、PTHREAD_MUTEX_RECURSIVE和PTHREAD _MUTEX_DEFAULT。它們分別定義了不同的上所、解鎖機制，一般情況下，選用最后一個默認屬性。
pthread_mutex_lock聲明開始用互斥鎖上鎖，此后的代碼直至調(diào)用pthread_mutex_unlock為止，均被上鎖，即同一時間只能被一個線程調(diào)用執(zhí)行。當(dāng)一個線程執(zhí)行到pthread_mutex_lock處時，如果該鎖此時被另一個線程使用，那此線程被阻塞，即程序?qū)⒌却搅硪粋�線程釋放此互斥鎖。在上面的例子中，我們使用了pthread_delay_np函數(shù)，讓線程睡眠一段時間，就是為了防止一個線程始終占據(jù)此函數(shù)。
上面的例子非常簡單，就不再介紹了，需要提出的是在使用互斥鎖的過程中很有可能會出現(xiàn)死鎖：兩個線程試圖同時占用兩個資源，并按不同的次序鎖定相應(yīng)的互斥鎖，例如兩個線程都需要鎖定互斥鎖1和互斥鎖2，a線程先鎖定互斥鎖1，b線程先鎖定互斥鎖2，這時就出現(xiàn)了死鎖。此時我們可以使用函數(shù)pthread_mutex_trylock，它是函數(shù)pthread_mutex_lock的非阻塞版本，當(dāng)它發(fā)現(xiàn)死鎖不可避免時，它會返回相應(yīng)的信息，程序員可以針對死鎖做出相應(yīng)的處理。另外不同的互斥鎖類型對死鎖的處理不一樣，但最主要的還是要程序員自己在程序設(shè)計注意這一點。
4.3 條件變量
前一節(jié)中我們講述了如何使用互斥鎖來實現(xiàn)線程間數(shù)據(jù)的共享和通信，互斥鎖一個明顯的缺點是它只有兩種狀態(tài)：鎖定和非鎖定。而條件變量通過允許線程阻塞和等待另一個線程發(fā)送信號的方法彌補了互斥鎖的不足，它常和互斥鎖一起使用。使用時，條件變量被用來阻塞一個線程，當(dāng)條件不滿足時，線程往往解開相應(yīng)的互斥鎖并等待條件發(fā)生變化。一旦其它的某個線程改變了條件變量，它將通知相應(yīng)的條件變量喚醒一個或多個正被此條件變量阻塞的線程。這些線程將重新鎖定互斥鎖并重新測試條件是否滿足。一般說來，條件變量被用來進行線承間的同步。
條件變量的結(jié)構(gòu)為pthread_cond_t，函數(shù)pthread_cond_init（）被用來初始化一個條件變量。它的原型為：
extern int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));
其中cond是一個指向結(jié)構(gòu)pthread_cond_t的指針，cond_attr是一個指向結(jié)構(gòu)pthread_condattr_t的指針。結(jié)構(gòu)pthread_condattr_t是條件變量的屬性結(jié)構(gòu)，和互斥鎖一樣我們可以用它來設(shè)置條件變量是進程內(nèi)可用還是進程間可用，默認值是PTHREAD_ PROCESS_PRIVATE，即此條件變量被同一進程內(nèi)的各個線程使用。注意初始化條件變量只有未被使用時才能重新初始化或被釋放。釋放一個條件變量的函數(shù)為pthread_cond_ destroy（pthread_cond_t cond）�！�
函數(shù)pthread_cond_wait（）使線程阻塞在一個條件變量上。它的函數(shù)原型為：
extern int pthread_cond_wait __P ((pthread_cond_t *__cond,
pthread_mutex_t *__mutex));
線程解開mutex指向的鎖并被條件變量cond阻塞。線程可以被函數(shù)pthread_cond_signal和函數(shù)pthread_cond_broadcast喚醒，但是要注意的是，條件變量只是起阻塞和喚醒線程的作用，具體的判斷條件還需用戶給出，例如一個變量是否為0等等，這一點我們從后面的例子中可以看到。線程被喚醒后，它將重新檢查判斷條件是否滿足，如果還不滿足，一般說來線程應(yīng)該仍阻塞在這里，被等待被下一次喚醒。這個過程一般用while語句實現(xiàn)。
另一個用來阻塞線程的函數(shù)是pthread_cond_timedwait（），它的原型為：
extern int pthread_cond_timedwait __P ((pthread_cond_t *__cond,
pthread_mutex_t *__mutex, __const struct timespec *__abstime));
它比函數(shù)pthread_cond_wait（）多了一個時間參數(shù)，經(jīng)歷abstime段時間后，即使條件變量不滿足，阻塞也被解除。
函數(shù)pthread_cond_signal（）的原型為：
extern int pthread_cond_signal __P ((pthread_cond_t *__cond));
它用來釋放被阻塞在條件變量cond上的一個線程。多個線程阻塞在此條件變量上時，哪一個線程被喚醒是由線程的調(diào)度策略所決定的。要注意的是，必須用保護條件變量的互斥鎖來保護這個函數(shù)，否則條件滿足信號又可能在測試條件和調(diào)用pthread_cond_wait函數(shù)之間被發(fā)出，從而造成無限制的等待。下面是使用函數(shù)pthread_cond_wait（）和函數(shù)pthread_cond_signal（）的一個簡單的例子。
pthread_mutex_t count_lock;
pthread_cond_t count_nonzero;
unsigned count;
decrement_count () {
pthread_mutex_lock (&count_lock);
while(count==0)
pthread_cond_wait( &count_nonzero, &count_lock);
count=count -1;
pthread_mutex_unlock (&count_lock);
}
increment_count(){
pthread_mutex_lock(&count_lock);
if(count==0)
pthread_cond_signal(&count_nonzero);
count=count+1;
pthread_mutex_unlock(&count_lock);
}
count值為0時，decrement函數(shù)在pthread_cond_wait處被阻塞，并打開互斥鎖count_lock。此時，當(dāng)調(diào)用到函數(shù)increment_count時，pthread_cond_signal（）函數(shù)改變條件變量，告知decrement_count（）停止阻塞。讀者可以試著讓兩個線程分別運行這兩個函數(shù)，看看會出現(xiàn)什么樣的結(jié)果。
函數(shù)pthread_cond_broadcast（pthread_cond_t *cond）用來喚醒所有被阻塞在條件變量cond上的線程。這些線程被喚醒后將再次競爭相應(yīng)的互斥鎖，所以必須小心使用這個函數(shù)。
4.4 信號量
信號量本質(zhì)上是一個非負的整數(shù)計數(shù)器，它被用來控制對公共資源的訪問。當(dāng)公共資源增加時，調(diào)用函數(shù)sem_post（）增加信號量。只有當(dāng)信號量值大于０時，才能使用公共資源，使用后，函數(shù)sem_wait（）減少信號量。函數(shù)sem_trywait（）和函數(shù)pthread_ mutex_trylock（）起同樣的作用，它是函數(shù)sem_wait（）的非阻塞版本。下面我們逐個介紹和信號量有關(guān)的一些函數(shù)，它們都在頭文件/usr/include/semaphore.h中定義。
信號量的數(shù)據(jù)類型為結(jié)構(gòu)sem_t，它本質(zhì)上是一個長整型的數(shù)。函數(shù)sem_init（）用來初始化一個信號量。它的原型為：
extern int sem_init __P ((sem_t *__sem, int __pshared, unsigned int __value));
sem為指向信號量結(jié)構(gòu)的一個指針；pshared不為０時此信號量在進程間共享，否則只能為當(dāng)前進程的所有線程共享；value給出了信號量的初始值。
函數(shù)sem_post( sem_t *sem )用來增加信號量的值。當(dāng)有線程阻塞在這個信號量上時，調(diào)用這個函數(shù)會使其中的一個線程不在阻塞，選擇機制同樣是由線程的調(diào)度策略決定的。
函數(shù)sem_wait( sem_t *sem )被用來阻塞當(dāng)前線程直到信號量sem的值大于0，解除阻塞后將sem的值減一，表明公共資源經(jīng)使用后減少。函數(shù)sem_trywait ( sem_t *sem )是函數(shù)sem_wait（）的非阻塞版本，它直接將信號量sem的值減一。
函數(shù)sem_destroy(sem_t *sem)用來釋放信號量sem。
下面我們來看一個使用信號量的例子。在這個例子中，一共有4個線程，其中兩個線程負責(zé)從文件讀取數(shù)據(jù)到公共的緩沖區(qū)，另兩個線程從緩沖區(qū)讀取數(shù)據(jù)作不同的處理（加和乘運算）。
/* File sem.c */
#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
#define MAXSTACK 100
int stack[MAXSTACK][2];
int size=0;
sem_t sem;
/* 從文件1.dat讀取數(shù)據(jù)，每讀一次，信號量加一*/
void ReadData1(void){
FILE *fp=fopen("1.dat","r");
while(!feof(fp)){
fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]);
sem_post(&sem);
++size;
}
fclose(fp);
}
/*從文件2.dat讀取數(shù)據(jù)*/
void ReadData2(void){
FILE *fp=fopen("2.dat","r");
while(!feof(fp)){
fscanf(fp,"%d %d",&stack[size][0],&stack[size][1]);
sem_post(&sem);
++size;
}
fclose(fp);
}
/*阻塞等待緩沖區(qū)有數(shù)據(jù)，讀取數(shù)據(jù)后，釋放空間，繼續(xù)等待*/
void HandleData1(void){
while(1){
sem_wait(&sem);
printf("Plus:%d+%d=%d\n",stack[size][0],stack[size][1],
stack[size][0]+stack[size][1]);
--size;
}
}
void HandleData2(void){
while(1){
sem_wait(&sem);
printf("Multiply:%d*%d=%d\n",stack[size][0],stack[size][1],
stack[size][0]*stack[size][1]);
--size;
}
}
int main(void){
pthread_t t1,t2,t3,t4;
sem_init(&sem,0,0);
pthread_create(&t1,NULL,(void *)HandleData1,NULL);
pthread_create(&t2,NULL,(void *)HandleData2,NULL);
pthread_create(&t3,NULL,(void *)ReadData1,NULL);
pthread_create(&t4,NULL,(void *)ReadData2,NULL);
/* 防止程序過早退出，讓它在此無限期等待*/
pthread_join(t1,NULL);
}
在Linux下，我們用命令gcc -lpthread sem.c -o sem生成可執(zhí)行文件sem。 我們事先編輯好數(shù)據(jù)文件1.dat和2.dat，假設(shè)它們的內(nèi)容分別為1 2 3 4 5 6 7 8 9 10和 -1 -2 -3 -4 -5 -6 -7 -8 -9 -10 ，我們運行sem，得到如下的結(jié)果：
Multiply:-1*-2=2
Plus:-1+-2=-3
Multiply:9*10=90
Plus:-9+-10=-19
Multiply:-7*-8=56
Plus:-5+-6=-11
Multiply:-3*-4=12
Plus:9+10=19
Plus:7+8=15
Plus:5+6=11
從中我們可以看出各個線程間的競爭關(guān)系。而數(shù)值并未按我們原先的順序顯示出來這是由于size這個數(shù)值被各個線程任意修改的緣故。這也往往是多線程編程要注意的問題。
5 小結(jié)
多線程編程是一個很有意思也很有用的技術(shù)，使用多線程技術(shù)的網(wǎng)絡(luò)螞蟻是目前最常用的下載工具之一，使用多線程技術(shù)的grep比單線程的grep要快上幾倍，類似的例子還有很多。希望大家能用多線程技術(shù)寫出高效實用的好程序來。 |
|
免費注冊
發(fā)表于 2008-06-26 15:18
發(fā)表于 2008-06-26 16:47
