Pthread 與 Linux

Pthread本來是一套使用者級線程庫, 但在Linux上實現時, 卻使用了核心級線程來完成, 這樣的好處是, 可以充分的提高程式的並發性, 線程也可以象以前一樣調用Head這樣的函數, 而不必擔心會由於阻賽影響其它的線程的運行. 但這樣一來, linux的線程就不是標準的了.

下面結合Linux上的實現來談一談Pthread.

一 基本概念
---------

Pthread是一套通用的線程庫, 它廣泛的被各種Unix所支援, 是由POSIX提出的. 因此, 它具有很好的客移植性. 在Linux上, 由於它是通過核心級線程來實現的, 就沒有完全的實現它. 但從功能上來看, 它絲毫不遜色.

先看一下下面的例子:
/* ------ test.c ------- */
#include
void *pp(void *arg)
{
while (1) {
printf(/"%s//n/", (char *)arg);
sleep(2);
}
return NULL;
}

main()
{
pthread_t pid;
pthread_create(&pid, NULL, pp, /"hello world/");
while (1) {
printf(/"I am main thread//n/");
sleep(1);
}
}

gcc test.c -lpthread
./a.out

I am main thread
hello world
I am main thread
hello world
............

在程式開始的時候, 系統建立了一個主線程, 又用pthread_create建立了一個新的子線程, 這樣, 兩個線程同時運行, 向螢幕上列印東西.

一個線程實際上就是一個函數, 建立後, 立即被執行, 當函數返回時該線程也就結束了.

下面這個函數用於建立一個新的線程:
int pthread_create (pthread_t *THREAD,
pthread_attr_t * ATTR,
void * (*START_ROUTINE)(void *),
void * ARG);

第一個參數是一個pthread_t型的指標用於儲存線程id. 以後對該線程的操作都要用id來標示.
第二個參數是一個pthread_attr_t的指標用於說明要建立的線程的屬性, 使用NULL, 表示要使用預設的屬性.
第三個參數指明了線程的如口, 是一個只有一個(void *)參數的函數.
第四個參數指明了要傳到線程如口函數的參數.

這很簡單, 上面的例子, 你也應該理解了.
象我在上面提過的一樣, 使用Linux的線程不需要對考慮對其它線程的阻塞問題, 這樣編程上就很方便.

二 傳回值
-------

也應該看到了, 每一個線程的傳回值是void *.
有兩種方法返回:
1 return pointer;
2 pthread_exit(pointer);
這兩種方法是一樣的.

那麼, 其他的線程是如何得到這個傳回值的呢?
用這個函數:
int pthread_join(pthread_t TH, void **thread_RETURN);

一個線程有兩種狀態, joinable 即系統保留線程的傳回值, 直到有另外一個線程將它取走. detach系統不保留傳回值.

下面的函數用於detach:
int pthread_detach (pthread_t TH);

pthread_t pthread_self(); 可以返回自己的id. 通常, 我們用下列
的語句來detach自己:
pthread_detach(pthread_self());

三 Mutex
--------

Mutex用於解決互斥問題. 一個Mutex是一個互斥裝置, 用於保護臨界區和共用記憶體. 它有兩種狀態locked, unlocked. 它不能同時被兩個線程所擁有.

下面的函數用於處理Mutex:

初始化一個Mutex
int pthread_mutex_init (pthread_mutex_t *MUTEX, const
pthread_mutexattr_t *MUTEXATTR);
鎖定一個Mutex
int pthread_mutex_lock (pthread_mutex_t *mutex));
試圖鎖定一個Mutex
int pthread_mutex_trylock (pthread_mutex_t *MUTEX);
結鎖一個Mutex
int pthread_mutex_unlock (pthread_mutex_t *MUTEX);
銷毀一個Mutext
int pthread_mutex_destroy (pthread_mutex_t *MUTEX);

它的鎖一共有三種: /"fast/", /"recursive/", or /"error checking/"
進行lock操作時:
如處於unlock狀態
lock它, 使它屬於自己.

在被其他線程lock的時候,
掛起當前線程, 直到被其他線程unlock

在已經被自己lock的時候,
/"fast/" 掛起當前線程.
/"resursive/" 成功並立刻返回當前被鎖定的次數
/"error checking/" 立刻返回EDEADLK

進行unlock操作時:
解鎖.
/"fast/" 喚醒第一個被鎖定的線程
/"recursive/" 減少lock數(這個數僅僅是被自己lock的, 不關其它線程的) 當lock數等於零的時候, 才被unlock並喚醒第一個被鎖定的線程.
/"error check/" 會檢查是不是自己lock的, 如果不是返回EPERM. 如果是喚醒第一個被鎖定的線程,

通常, 我們用一些靜態變數來初始化mutex.
/"fast/" `PTHREAD_MUTEX_INITIALIZER/
/"recursive/" `PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP/
/"error check/" `PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP/

注意: _NP 表示no portable不可移植

例如:
// /"fast/" type mutex
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
... ...
pthread_mutext_lock(&mutex);
fwrite(buffer, 1, strlen(buffer), file);
pthread_mutex_unlock(&mutex);
... ...

看起來有一點難懂, 自己編幾個程式就很容易理解了.

四 Condition Variable (條件變數)
------------------------------

也是一種用於同步的device. 允許一個進程將自己掛起等待一個條件變數被改變狀態.
有下列幾個函數:

int pthread_cond_init (pthread_cond_t *COND,
pthread_condattr_t *cond_ATTR);
int pthread_cond_signal (pthread_cond_t *COND);
int pthread_cond_broadcast (pthread_cond_t *COND);
int pthread_cond_wait (pthread_cond_t *COND,
pthread_mutex_t *MUTEX);
int pthread_cond_timedwait (pthread_cond_t *COND,
pthread_mutex_t *MUTEX,
const struct timespec *ABSTIME);
int pthread_cond_destroy (pthread_cond_t *COND);

我想看看名字就可以知道它們的用途了. 通常我們也使用靜態變數來初始化一個條件變數.
Example:
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

pthread_cond_signal 用於喚醒一個被鎖定的線程.
pthread_cond_broadcast 用於喚醒所有被鎖定的線程.

pthread_cont_wait 用於等待.
為瞭解決競爭問題(即一個線程剛要去wait而另一個線程已經signal了), 它要與一個
metux連用.

看一看下面的例子:

int x,y;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

//Waiting until X is greater than Y is performed as follows:

pthread_mutex_lock(&mut);
while (x <= y) {
pthread_cond_wait(&cond, &mut);
}
/* operate on x and y */
pthread_mutex_unlock(&mut);

pthread_cond_wait的執行過程如下:
1. 首先, 它unlock the mutex, then 掛起當前的線程.
2. 當被喚醒的時候, 它會lock the mutex.

這樣就保證了這是一個臨界區.

五 Thread-Specific Data (TSD)
----------------------------

說白了就是線程中使用的靜態變數. 大家可以很容易的理解為什麼使用靜態變數函數不是線
程安全的(也就是它們一定要很小心的線上程中使用).

而使用靜態變數又是很方便的, 這就產生了 thread-specific data. 可以把它理解為
一個指標數組, 但對於每個線程來說是唯一的.

Example:
int func()
{
char *p;
p = strdup(thread-specific-data[1]);
... ...
}

void *pthread-1(void *arg)
{
... ...
func()
... ...
}

void *pthread-2(void *arg)
{
... ...
func()
... ...
}

不同的線程調用func產生的結果是不同的. 這隻是個例子.

int pthread_key_create(pthread_key_t *KEY, void
(*destr_function) (void *));
int pthread_key_delete(pthread_key_t KEY);
int pthread_setspecific(pthread_key_t KEY, const void
*POINTER);
void * pthread_getspecific(pthread_key_t KEY);

TSD可以看成是一個void *的數組.
注意: pthread_key_delete只是釋放key佔用的空間, 你仍然需要釋放那個
void *.

為了加深你的理解, 看一看下面的例子吧:
/* Key for the thread-specific buffer */
static pthread_key_t buffer_key;

/* Once-only initialisation of the key */
static pthread_once_t buffer_key_once = PTHREAD_ONCE_INIT;

/* Allocate the thread-specific buffer */
void buffer_alloc(void)
{
pthread_once(&buffer_key_once, buffer_key_alloc);
pthread_setspecific(buffer_key, malloc(100));
}

/* Return the thread-specific buffer */
char * get_buffer(void)
{
return (char *) pthread_getspecific(buffer_key);
}

/* Allocate the key */
static void buffer_key_alloc()
{
pthread_key_create(&buffer_key, buffer_destroy);
}

/* Free the thread-specific buffer */
static void buffer_destroy(void * buf)
{
free(buf);
}

六. 訊號處理
------------

線上程中的訊號處理是這個樣子, 所有的線程共用一組, 訊號處理函數.
而每一個線程有自己的訊號掩碼.

下面是用於處理線程訊號的函數:
int pthread_sigmask (int HOW, const sigset_t *NEWMASK,
sigset_t *OLDMASK);
int pthread_kill (pthread_t THREAD, int SIGNO);
int sigwait (const sigset_t *SET, int *SIG);

可以使用sigaction來安裝訊號處理函數.

看一看下面的程式:
#include
#include
void *pp(void *)
{
printf(/"ha ha/");
alarm(1);
}
void main_alarm(int i)
{
printf(/"Main got//n/");
alarm(3);
}

main()
{
pthread_t pid;
struct sigaction aa;
sigset_t sigt;

sigfillset(&sigt);
aa.sa_handler = mainalarm;
aa.sa_mask = sigt;
aa.sa_flags = 0;
sigaction(SIGALRM, &aa, NULL);

pthread_create(&pid, NULL, pp, NULL);
while(1);
return 0;
}

七. 放棄 (Cancellation)
-----------------------

這是一種機制: 一個線程可以結束另一個線程. 精確的說, 一個線程可以
向另一個線程發送 cancellation 請求. 另一個線程根據其設定, 可以忽
略掉該請求, 也可以在到達一個cancellation點時, 來處理它.

當一個線程處理一個cancellaction請求時, pthread_exit 一個一個的調
用 cleanup handlers. 所謂的一個cancellation點是在這些地方, 線程會
處理cancellation請求. POSIX中的函數: pthread_join
pthread_cond_wait pthread_cond_timewait pthread_testcancel sem_wait
sigwait 都是cancellation點. 下面的這些系統函數也是cancellation點:
accept open sendmsg
close pause sendto
connect read system
fcntl recv tcdrain
fsync recvfrom wait
lseek recvmsg waitpid
msync send write
nanosleep

其它的一些函數如果調用了上面的函數, 那麼, 它們也是cancellation點.
int pthread_setcancelstate (int STATE, int *OLDSTATE);
用於允許或禁止處理cancellation,
STATE可以是:PTHREAD_CANCEL_ENABLE PTHREAD_CANCEL_DISABLE

int pthread_setcanceltype (int TYPE, int *OLDTYPE);
設定如何處理cancellation, 非同步還是延遲的.
TYPE可以是:PTHREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_DEFERRED
void pthread_testcancel (VOID);

八. 清理函數 (Cleanup Handlers)
-------------------------------

這是一些函數, 它們會被pthread_exit按順序調用. 它們以棧風格被管理.
這種機制的目的是希望在退出前釋放掉一些佔用的資源.

例如: 我們使用了一個MUTEX, 但希望在cancellation時能unlock它.

pthread_cleanup_push(pthread_mutex_unlock, (void *)&mut);
pthread_mutex_lock(&mut);
/* do some work */
pthread_mutex_unlock(&mut);
pthread_cleanip_pop(0);

注意:
在非同步處理過程中, 一個cancellation可以發生在pthread_cleaup_push
和pthread_mutex_lock之間. 這中情況是很糟糕的. 所以, 非同步cancellation
是很難用的.

void pthread_cleanup_push (void (*ROUTINE) (void *), void *ARG);
void pthread_cleanup_pop (int EXECUTE);
如果EXECUTE不等於0, 則在出棧後, 會被執行一次.

九. 訊號量 (Semaphores)
-----------------------

Semaphores是線程間共用的資源計數器.
基本的訊號量操作為: 原子的增加訊號量, 原子的減少訊號量, 等待直到
訊號量的值為非零.

在POSIX中, 訊號量有一個最大值, 宏SEM_VALUE_MAX定義了該值. 在GNU
的LIBC中, 該值等於INT_MAX (太大了).

下面是相關的函數:

int sem_init (sem_t *SEM, int PSHARED, unsigned int VALUE);
初始化一個訊號量, 其值為VALUE, PSHARED指明它是不是共用的.
0 表示local, 非0表示是全域的.

int sem_destroy (sem_t * SEM);
釋放掉相關的資源.

int sem_wait (sem_t * SEM);
等待直到SEM的值為非零.

int sem_trywait (sem_t * SEM);

int sem_post (sem_t * SEM);
將訊號量加1.

int sem_getvalue (sem_t * SEM, int * SVAL);
取得訊號量的值.