clone的fork与pthread_create创建线程有何不同pthread多线程编程的学习小结(转)
進(jìn)程是一個(gè)指令執(zhí)行流及其執(zhí)行環(huán)境，其執(zhí)行環(huán)境是一個(gè)系統(tǒng)資源的集合，這些資源在Linux中被抽
象成各種數(shù)據(jù)對(duì)象：進(jìn)程控制塊、虛存空間、文件系統(tǒng)，文件I/O、信號(hào)處理函數(shù)。所以創(chuàng)建一個(gè)進(jìn)程的
過(guò)程就是這些數(shù)據(jù)對(duì)象的創(chuàng)建過(guò)程。
在調(diào)用系統(tǒng)調(diào)用fork創(chuàng)建一個(gè)進(jìn)程時(shí)，子進(jìn)程只是完全復(fù)制父進(jìn)程的資源，這樣得到的子進(jìn)程獨(dú)立于
父進(jìn)程，具有良好的并發(fā)性，但是二者之間的通訊需要通過(guò)專門(mén)的通訊機(jī)制，如：pipe，fifo，System V
IPC機(jī)制等，另外通過(guò)fork創(chuàng)建子進(jìn)程系統(tǒng)開(kāi)銷(xiāo)很大，需要將上面描述的每種資源都復(fù)制一個(gè)副本。這樣
看來(lái)，fork是一個(gè)開(kāi)銷(xiāo)十分大的系統(tǒng)調(diào)用，這些開(kāi)銷(xiāo)并不是所有的情況下都是必須的，比如某進(jìn)程fork出
一個(gè)子進(jìn)程后，其子進(jìn)程僅僅是為了調(diào)用exec執(zhí)行另一個(gè)執(zhí)行文件，那么在fork過(guò)程中對(duì)于虛存空間的復(fù)
制將是一個(gè)多余的過(guò)程（由于Linux中是采取了copy-on-write技術(shù)，所以這一步驟的所做的工作只是虛存
管理部分的復(fù)制以及頁(yè)表的創(chuàng)建，而并沒(méi)有包括物理也面的拷貝）；另外，有時(shí)一個(gè)進(jìn)程中具有幾個(gè)獨(dú)立
的計(jì)算單元，可以在相同的地址空間上基本無(wú)沖突進(jìn)行運(yùn)算，但是為了把這些計(jì)算單元分配到不同的處理
器上，需要?jiǎng)?chuàng)建幾個(gè)子進(jìn)程，然后各個(gè)子進(jìn)程分別計(jì)算最后通過(guò)一定的進(jìn)程間通訊和同步機(jī)制把計(jì)算結(jié)果
匯總，這樣做往往有許多格外的開(kāi)銷(xiāo)，而且這種開(kāi)銷(xiāo)有時(shí)足以抵消并行計(jì)算帶來(lái)的好處。
另 進(jìn)程是系統(tǒng)中程序執(zhí)行和資源分配的基本單位。每個(gè)進(jìn)程都擁有自己的
數(shù)據(jù)段、代碼段和堆棧段，這就造成了進(jìn)程在進(jìn)行切換等操作時(shí)都需要有比較負(fù)責(zé)的上下文
切換等動(dòng)作。為了進(jìn)一步減少處理機(jī)的空轉(zhuǎn)時(shí)間支持多處理器和減少上下文切換開(kāi)銷(xiāo)
這說(shuō)明了把計(jì)算單元抽象到進(jìn)程上是不充分的，這也就是許多系統(tǒng)中都引入了線程的概念的原因。在
講述線程前首先介紹以下vfork系統(tǒng)調(diào)用，vfork系統(tǒng)調(diào)用不同于fork，用vfork創(chuàng)建的子進(jìn)程共享地址空
間，也就是說(shuō)子進(jìn)程完全運(yùn)行在父進(jìn)程的地址空間上，子進(jìn)程對(duì)虛擬地址空間任何數(shù)據(jù)的修改同樣為父進(jìn)
程所見(jiàn)。但是用vfork創(chuàng)建子進(jìn)程后，父進(jìn)程會(huì)被阻塞直到子進(jìn)程調(diào)用exec或exit。這樣的好處是在子進(jìn)
程被創(chuàng)建后僅僅是為了調(diào)用exec執(zhí)行另一個(gè)程序時(shí)，因?yàn)樗筒粫?huì)對(duì)父進(jìn)程的地址空間有任何引用，所以
對(duì)地址空間的復(fù)制是多余的，通過(guò)vfork可以減少不必要的開(kāi)銷(xiāo)。
在Linux中， fork和vfork都是調(diào)用同一個(gè)核心函數(shù)
do_fork(unsigned long clone_flag, unsigned long usp, structpt_regs)
其中clone_flag包括CLONE_VM, CLONE_FS, CLONE_FILES, CLONE_SIGHAND,CLONE_PID，CLONE_VFORK
等等標(biāo)志位，任何一位被置1了則表明創(chuàng)建的子進(jìn)程和父進(jìn)程共享該位對(duì)應(yīng)的資源。所以在vfork的實(shí)現(xiàn)中
，cloneflags = CLONE_VFORK | CLONE_VM |SIGCHLD，這表示子進(jìn)程和父進(jìn)程共享地址空間，同時(shí)
do_fork會(huì)檢查CLONE_VFORK，如果該位被置1了，子進(jìn)程會(huì)把父進(jìn)程的地址空間鎖住，直到子進(jìn)程退出或
執(zhí)行exec時(shí)才釋放該鎖。
在講述clone系統(tǒng)調(diào)用前先簡(jiǎn)單介紹線程的一些概念。
線程是在進(jìn)程的基礎(chǔ)上進(jìn)一步的抽象，也就是說(shuō)一個(gè)進(jìn)程分為兩個(gè)部分：線程集合和資源集合。線程
是進(jìn)程中的一個(gè)動(dòng)態(tài)對(duì)象，它應(yīng)該是一組獨(dú)立的指令流，進(jìn)程中的所有線程將共享進(jìn)程里的資源。但是線
程應(yīng)該有自己的私有對(duì)象：比如程序計(jì)數(shù)器、堆棧和寄存器上下文。
線程分為三種類型：
內(nèi)核線程、輕量級(jí)進(jìn)程和用戶線程。
內(nèi)核線程：
它的創(chuàng)建和撤消是由內(nèi)核的內(nèi)部需求來(lái)決定的，用來(lái)負(fù)責(zé)執(zhí)行一個(gè)指定的函數(shù)，一個(gè)內(nèi)核線程不需要
和一個(gè)用戶進(jìn)程聯(lián)系起來(lái)。它共享內(nèi)核的正文段核全局?jǐn)?shù)據(jù)，具有自己的內(nèi)核堆棧。它能夠單獨(dú)的被調(diào)度
并且使用標(biāo)準(zhǔn)的內(nèi)核同步機(jī)制，可以被單獨(dú)的分配到一個(gè)處理器上運(yùn)行。內(nèi)核線程的調(diào)度由于不需要經(jīng)過(guò)
態(tài)的轉(zhuǎn)換并進(jìn)行地址空間的重新映射，因此在內(nèi)核線程間做上下文切換比在進(jìn)程間做上下文切換快得多。
輕量級(jí)進(jìn)程：
輕量級(jí)進(jìn)程是核心支持的用戶線程，它在一個(gè)單獨(dú)的進(jìn)程中提供多線程控制。這些輕量級(jí)進(jìn)程被單獨(dú)
的調(diào)度，可以在多個(gè)處理器上運(yùn)行，每一個(gè)輕量級(jí)進(jìn)程都被綁定在一個(gè)內(nèi)核線程上，而且在它的生命周期
這種綁定都是有效的。輕量級(jí)進(jìn)程被獨(dú)立調(diào)度并且共享地址空間和進(jìn)程中的其它資源，但是每個(gè)LWP都應(yīng)
該有自己的程序計(jì)數(shù)器、寄存器集合、核心棧和用戶棧。
用戶線程：
用戶線程是通過(guò)線程庫(kù)實(shí)現(xiàn)的。它們可以在沒(méi)有內(nèi)核參與下創(chuàng)建、釋放和管理。線程庫(kù)提供了同步和
調(diào)度的方法。這樣進(jìn)程可以使用大量的線程而不消耗內(nèi)核資源，而且省去大量的系統(tǒng)開(kāi)銷(xiāo)。用戶線程的實(shí)
現(xiàn)是可能的，因?yàn)橛脩艟€程的上下文可以在沒(méi)有內(nèi)核干預(yù)的情況下保存和恢復(fù)。每個(gè)用戶線程都可以有自
己的用戶堆棧，一塊用來(lái)保存用戶級(jí)寄存器上下文以及如信號(hào)屏蔽等狀態(tài)信息的內(nèi)存區(qū)。庫(kù)通過(guò)保存當(dāng)前
線程的堆棧和寄存器內(nèi)容載入新調(diào)度線程的那些內(nèi)容來(lái)實(shí)現(xiàn)用戶線程之間的調(diào)度和上下文切換。
內(nèi)核仍然負(fù)責(zé)進(jìn)程的切換，因?yàn)橹挥袃?nèi)核具有修改內(nèi)存管理寄存器的權(quán)力。用戶線程不是真正的調(diào)度
實(shí)體，內(nèi)核對(duì)它們一無(wú)所知，而只是調(diào)度用戶線程下的進(jìn)程或者輕量級(jí)進(jìn)程，這些進(jìn)程再通過(guò)線程庫(kù)函數(shù)
來(lái)調(diào)度它們的線程。當(dāng)一個(gè)進(jìn)程被搶占時(shí)，它的所有用戶線程都被搶占，當(dāng)一個(gè)用戶線程被阻塞時(shí)，它會(huì)
阻塞下面的輕量級(jí)進(jìn)程，如果進(jìn)程只有一個(gè)輕量級(jí)進(jìn)程，則它的所有用戶線程都會(huì)被阻塞。
明確了這些概念后，來(lái)講述Linux的線程和clone系統(tǒng)調(diào)用。
在許多實(shí)現(xiàn)了MT的操作系統(tǒng)中（如：Solaris，Digital Unix等）， 線程和進(jìn)程通過(guò)兩種數(shù)據(jù)結(jié)構(gòu)來(lái)
抽象表示： 進(jìn)程表項(xiàng)和線程表項(xiàng)，一個(gè)進(jìn)程表項(xiàng)可以指向若干個(gè)線程表項(xiàng)， 調(diào)度器在進(jìn)程的時(shí)間片內(nèi)再
調(diào)度線程。 但是在Linux中沒(méi)有做這種區(qū)分， 而是統(tǒng)一使用task_struct來(lái)管理所有進(jìn)程/線程，只是
線程與線程之間的資源是共享的，這些資源可是是前面提到過(guò)的：虛存、文件系統(tǒng)、文件I/O以及信號(hào)處
理函數(shù)甚至PID中的幾種。
也就是說(shuō)Linux中，每個(gè)線程都有一個(gè)task_struct，所以線程和進(jìn)程可以使用同一調(diào)度器調(diào)度。其實(shí)
Linux核心中，輕量級(jí)進(jìn)程和進(jìn)程沒(méi)有質(zhì)上的差別，因?yàn)長(zhǎng)inux中進(jìn)程的概念已經(jīng)被抽象成了計(jì)算狀態(tài)加資
源的集合，這些資源在進(jìn)程間可以共享。如果一個(gè)task獨(dú)占所有的資源，則是一個(gè)HWP，如果一個(gè)task和
其它task共享部分資源，則是LWP。
clone系統(tǒng)調(diào)用就是一個(gè)創(chuàng)建輕量級(jí)進(jìn)程的系統(tǒng)調(diào)用：
int clone(int (fn)(void arg), void stack, int flags, void arg);
其中fn是輕量級(jí)進(jìn)程所執(zhí)行的過(guò)程，stack是輕量級(jí)進(jìn)程所使用的堆棧，flags可以是前面提到的
CLONE_VM, CLONE_FS, CLONE_FILES, CLONE_SIGHAND,CLONE_PID的組合。Clone和fork，vfork在實(shí)現(xiàn)時(shí)
都是調(diào)用核心函數(shù)do_fork。
do_fork(unsigned long clone_flag, unsigned long usp, structpt_regs)；
和fork、vfork不同的是，fork時(shí)clone_flag = SIGCHLD；
vfork時(shí)clone_flag = CLONE_VM | CLONE_VFORK | SIGCHLD；
而在clone中，clone_flag由用戶給出。
下面給出一個(gè)使用clone的例子。
Void * func(int arg)
{
.. . . . .}
int main()
{
int clone_flag, arg;.. . . . .clone_flag = CLONE_VM | CLONE_SIGHAND | CLONE_FS |CLONE_FILES;stack = (char *)malloc(STACK_FRAME);stack += STACK_FRAME;retval = clone((void *)func, stack, clone_flag, arg);.. . . . .}
看起來(lái)clone的用法和pthread_create有些相似，兩者的最根本的差別在于clone是創(chuàng)建一個(gè)LWP，對(duì)
核心是可見(jiàn)的，由核心調(diào)度，而pthread_create通常只是創(chuàng)建一個(gè)用戶線程，對(duì)核心是不可見(jiàn)的，由線程
庫(kù)調(diào)度。
linux的pthread_create最終調(diào)用clone,pthread_create調(diào)用clone,并把開(kāi)辟一個(gè)stack作為參數(shù)
thread 建立, 同步,銷(xiāo)毀等由線程庫(kù)負(fù)責(zé),
pthread多線程編程整理
1 Introduction
不用介紹了吧…
2 Thread Concepts
a. Thread ID
b. Stack
c. Policy
d. Signal mask
e. Errno
f. Thread-Specific Data
3 Thread Identification
int pthread_equal(pthread_t tid1, pthread_t tid2)
pthread _t pthread_self(void);
4 Thread Creation
int pthread_create(
pthread_t restrict tidp,
const pthread_attr_t restrict attr,
void (start_rtn)(void ), void restrict arg);
a. pthread_t *restrict tidp：返回最后創(chuàng)建出來(lái)的Thread的Thread ID
b. const pthread_attr_t *restrict attr：指定線程的Attributes，后面會(huì)講道，現(xiàn)在可以用NULL
c. void (start_rtn)(void )：指定線程函數(shù)指針，該函數(shù)返回一個(gè)void ，參數(shù)也為void*
d. void *restrict arg：傳入給線程函數(shù)的參數(shù)
e. 返回錯(cuò)誤值。
a. 在線程函數(shù)中return
b. 被同一進(jìn)程中的另外的線程Cancel掉
c. 線程調(diào)用pthread_exit函數(shù)
a. 線程A調(diào)用pthread_join(B, &rval_ptr)，被Block，進(jìn)入Detached狀態(tài)（如果已經(jīng)進(jìn)入Detached狀態(tài)，則pthread_join函數(shù)返回EINVAL）。如果對(duì)B的結(jié)束代碼不感興趣，rval_ptr可以傳NULL。
b. 線程B調(diào)用pthread_exit(rval_ptr)，退出線程B，結(jié)束代碼為rval_ptr。注意rval_ptr指向的內(nèi)存的生命周期，不應(yīng)該指向B的Stack中的數(shù)據(jù)。
c. 線程A恢復(fù)運(yùn)行，pthread_join函數(shù)調(diào)用結(jié)束，線程B的結(jié)束代碼被保存到rval_ptr參數(shù)中去。如果線程B被Cancel，那么rval_ptr的值就是PTHREAD_CANCELLED。
兩個(gè)函數(shù)原型如下：
＃i nclude <pthread.h>
void pthread_exit(void *rval_ptr);
int pthread_join(pthread_t thread, void **rval_ptr);
void pthread_cancel(pthread_t tid)
該函數(shù)會(huì)使指定線程如同調(diào)用了pthread_exit(PTHREAD_CANCELLED)。不過(guò)，指定線程可以選擇忽略或者進(jìn)行自己的處理，在后面會(huì)講到。此外，該函數(shù)不會(huì)導(dǎo)致Block，只是發(fā)送Cancel這個(gè)請(qǐng)求。
void pthread_cleanup_push(void (rtn)(void ), void *arg);
void pthread_cleanup_pop(int execute);
這兩個(gè)函數(shù)維護(hù)一個(gè)函數(shù)指針的Stack，可以把函數(shù)指針和函數(shù)參數(shù)值push/pop。執(zhí)行的順序則是從棧頂?shù)綏５?#xff0c;也就是和push的順序相反。
在下面情況下pthread_cleanup_push所指定的thread cleanup handlers會(huì)被調(diào)用：
a. 調(diào)用pthread_exit
b. 相應(yīng)cancel請(qǐng)求
c. 以非0參數(shù)調(diào)用pthread_cleanup_pop()。（如果以0調(diào)用pthread_cleanup_pop()，那么handler不會(huì)被調(diào)用
有一個(gè)比較怪異的要求是，由于這兩個(gè)函數(shù)可能由宏的方式來(lái)實(shí)現(xiàn)，因此這兩個(gè)函數(shù)的調(diào)用必須得是在同一個(gè)Scope之中，并且配對(duì)，因?yàn)樵趐thread_cleanup_push的實(shí)現(xiàn)中可能有一個(gè){，而 pthread_cleanup_pop可能有一個(gè)}。因此，一般情況下，這兩個(gè)函數(shù)是用于處理意外情況用的，舉例如下：
void thread_func(void arg)
{
pthread_cleanup_push(cleanup, “handler”)
}
Thread Primitive
Description
fork
pthread_create
創(chuàng)建新的控制流
exit
pthread_exit
退出已有的控制流
waitpid
pthread_join
等待控制流并獲得結(jié)束代碼
atexit
pthread_cleanup_push
注冊(cè)在控制流退出時(shí)候被調(diào)用的函數(shù)
getpid
pthread_self
獲得控制流的id
abort
pthread_cancel
請(qǐng)求非正常退出
int pthread_detach(pthread_t tid);
通過(guò)修改調(diào)用pthread_create函數(shù)的attr參數(shù)，我們可以指定一個(gè)線程在創(chuàng)建之后立刻就進(jìn)入Detached狀態(tài)
6 Thread Synchronization
a. 用于互斥訪問(wèn)
b. 類型：pthread_mutex_t，必須被初始化為PTHREAD_MUTEX_INITIALIZER（用于靜態(tài)分配的mutex，等價(jià)于 pthread_mutex_init(…, NULL)）或者調(diào)用pthread_mutex_init。Mutex也應(yīng)該用pthread_mutex_destroy來(lái)銷(xiāo)毀。這兩個(gè)函數(shù)原型如下：（attr的具體含義下一章討論）
＃i nclude <pthread.h>
int pthread_mutex_init(
pthread_mutex_t restrict mutex,
const pthread_mutexattr_t restrict attr)
int pthread_mutex_destroy(pthread_mutex_t *mutex);
c. pthread_mutex_lock 用于Lock Mutex，如果Mutex已經(jīng)被Lock，該函數(shù)調(diào)用會(huì)Block直到Mutex被Unlock，然后該函數(shù)會(huì)Lock Mutex并返回。pthread_mutex_trylock類似，只是當(dāng)Mutex被Lock的時(shí)候不會(huì)Block，而是返回一個(gè)錯(cuò)誤值EBUSY。 pthread_mutex_unlock則是unlock一個(gè)mutex。這三個(gè)函數(shù)原型如下：
＃i nclude <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
a. 多個(gè)線程可以同時(shí)獲得讀鎖(Reader-Writer lock in read mode)，但是只有一個(gè)線程能夠獲得寫(xiě)鎖(Reader-writer lock in write mode)
b. 讀寫(xiě)鎖有三種狀態(tài)
i. 一個(gè)或者多個(gè)線程獲得讀鎖，其他線程無(wú)法獲得寫(xiě)鎖
ii. 一個(gè)線程獲得寫(xiě)鎖，其他線程無(wú)法獲得讀鎖
iii. 沒(méi)有線程獲得此讀寫(xiě)鎖
c. 類型為pthread_rwlock_t
d. 創(chuàng)建和關(guān)閉方法如下：
＃i nclude <pthread.h>
int pthread_rwlock_init(
pthread_rwlock_t restrict rwlock,
const pthread_rwlockattr_t restrict attr)
int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);
e. 獲得讀寫(xiě)鎖的方法如下：
＃i nclude <pthread.h>
int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);
int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);
pthread_rwlock_rdlock：獲得讀鎖
pthread_rwlock_wrlock：獲得寫(xiě)鎖
pthread_rwlock_unlock：釋放鎖，不管是讀鎖還是寫(xiě)鎖都是調(diào)用此函數(shù)
注意具體實(shí)現(xiàn)可能對(duì)同時(shí)獲得讀鎖的線程個(gè)數(shù)有限制，所以在調(diào)用 pthread_rwlock_rdlock的時(shí)候需要檢查錯(cuò)誤值，而另外兩個(gè)pthread_rwlock_wrlock和 pthread_rwlock_unlock則一般不用檢查，如果我們代碼寫(xiě)的正確的話。
a. 條件必須被Mutex保護(hù)起來(lái)
b. 類型為：pthread_cond_t，必須被初始化為PTHREAD_COND_INITIALIZER（用于靜態(tài)分配的條件，等價(jià)于pthread_cond_init(…, NULL)）或者調(diào)用pthread_cond_init
＃i nclude <pthread.h>
int pthread_cond_init(
pthread_cond_t restrict cond,
const pthread_condxattr_t restrict attr)
int pthread_cond_destroy(pthread_cond_t *cond);
c. pthread_cond_wait 函數(shù)用于等待條件發(fā)生（=true）。pthread_cond_timedwait類似，只是當(dāng)?shù)却瑫r(shí)的時(shí)候返回一個(gè)錯(cuò)誤值ETIMEDOUT。超時(shí)的時(shí)間用timespec結(jié)構(gòu)指定。此外，兩個(gè)函數(shù)都需要傳入一個(gè)Mutex用于保護(hù)條件
＃i nclude <pthread.h>
int pthread_cond_wait(
pthread_cond_t restrict cond,
pthread_mutex_t restrict mutex);
int pthread_cond_timedwait(
pthread_cond_t restrict cond,
pthread_mutex_t restrict mutex,
const struct timespec *restrict timeout);
d. timespec結(jié)構(gòu)定義如下：
struct timespec {
time_t tv_sec; /* seconds /
long tv_nsec; / nanoseconds */
};
注意timespec的時(shí)間是絕對(duì)時(shí)間而非相對(duì)時(shí)間，因此需要先調(diào)用gettimeofday函數(shù)獲得當(dāng)前時(shí)間，再轉(zhuǎn)換成timespec結(jié)構(gòu)，加上偏移量。
e. 有兩個(gè)函數(shù)用于通知線程條件被滿足（=true）：
＃i nclude <pthread.h>
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
兩者的區(qū)別是前者會(huì)喚醒單個(gè)線程，而后者會(huì)喚醒多個(gè)線程。
在傳統(tǒng)的Unix模型中，當(dāng)一個(gè)進(jìn)程需要由另一個(gè)實(shí)體執(zhí)行某件事時(shí)，該進(jìn)程派生（fork）一個(gè)子進(jìn)程，讓子進(jìn)程去進(jìn)行處理。Unix下的大多數(shù)網(wǎng)絡(luò)服務(wù)器程序都是這么編寫(xiě)的，即父進(jìn)程接受連接，派生子進(jìn)程，子進(jìn)程處理與客戶的交互。
雖然這種模型很多年來(lái)使用得很好，但是fork時(shí)有一些問(wèn)題：
fork是昂貴的。內(nèi)存映像要從父進(jìn)程拷貝到子進(jìn)程，所有描述字要在子進(jìn)程中復(fù)制等等。目前有的Unix實(shí)現(xiàn)使用一種叫做寫(xiě)時(shí)拷貝（copy－on－write）的技術(shù)，可避免父進(jìn)程數(shù)據(jù)空間向子進(jìn)程的拷貝。盡管有這種優(yōu)化技術(shù)，fork仍然是昂貴的。
fork子進(jìn)程后，需要用進(jìn)程間通信（IPC）在父子進(jìn)程之間傳遞信息。Fork之前的信息容易傳遞，因?yàn)樽舆M(jìn)程從一開(kāi)始就有父進(jìn)程數(shù)據(jù)空間及所有描述字的拷貝。但是從子進(jìn)程返回信息給父進(jìn)程需要做更多的工作。
線程有助于解決這兩個(gè)問(wèn)題。線程有時(shí)被稱為輕權(quán)進(jìn)程（lightweight process），因?yàn)榫€程比進(jìn)程“輕權(quán)”，一般來(lái)說(shuō)，創(chuàng)建一個(gè)線程要比創(chuàng)建一個(gè)進(jìn)程快10～100倍。
一個(gè)進(jìn)程中的所有線程共享相同的全局內(nèi)存，這使得線程很容易共享信息，但是這種簡(jiǎn)易性也帶來(lái)了同步問(wèn)題。
一個(gè)進(jìn)程中的所有線程不僅共享全局變量，而且共享：進(jìn)程指令、大多數(shù)數(shù)據(jù)、打開(kāi)的文件（如描述字）、信號(hào)處理程序和信號(hào)處置、當(dāng)前工作目錄、用戶ID和組ID。但是每個(gè)線程有自己的線程ID、寄存器集合（包括程序計(jì)數(shù)器和棧指針）、棧（用于存放局部變量和返回地址）、error、信號(hào)掩碼、優(yōu)先級(jí)。在Linux中線程編程符合Posix.1標(biāo)準(zhǔn)，稱為Pthreads。所有的pthread函數(shù)都以pthread_開(kāi)頭。以下先講述5個(gè)基本線程函數(shù)，在調(diào)用它們前均要包括pthread.h頭文件。然后再給出用它們編寫(xiě)的一個(gè)TCP客戶/服務(wù)器程序例子。
第一個(gè)函數(shù)：
int pthread_create (pthread_t ＊tid,const pthread_attr_t ＊attr,void ＊ (＊func)(void ＊),void ＊arg)；
一個(gè)進(jìn)程中的每個(gè)線程都由一個(gè)線程ID（thread ID）標(biāo)識(shí)，其數(shù)據(jù)類型是pthread_t（常常是unsigned int）。如果新的線程創(chuàng)建成功，其ID將通過(guò)tid指針?lè)祷亍?/p>
每個(gè)線程都有很多屬性：優(yōu)先級(jí)、起始棧大小、是否應(yīng)該是一個(gè)守護(hù)線程等等，當(dāng)創(chuàng)建線程時(shí)，我們可通過(guò)初始化一個(gè)pthread_attr_t變量說(shuō)明這些屬性以覆蓋缺省值。我們通常使用缺省值，在這種情況下，我們將attr參數(shù)說(shuō)明為空指針。
最后，當(dāng)創(chuàng)建一個(gè)線程時(shí)，我們要說(shuō)明一個(gè)它將執(zhí)行的函數(shù)。線程以調(diào)用該函數(shù)開(kāi)始，然后或者顯式地終止（調(diào)用pthread_exit）或者隱式地終止（讓該函數(shù)返回）。函數(shù)的地址由func參數(shù)指定，該函數(shù)的調(diào)用參數(shù)是一個(gè)指針arg，如果我們需要多個(gè)調(diào)用參數(shù)，我們必須將它們打包成一個(gè)結(jié)構(gòu)，然后將其地址當(dāng)作唯一的參數(shù)傳遞給起始函數(shù)。
在func和arg的聲明中，func函數(shù)取一個(gè)通用指針（void ＊）參數(shù)，并返回一個(gè)通用指針（void ＊），這就使得我們可以傳遞一個(gè)指針（指向任何我們想要指向的東西）給線程，由線程返回一個(gè)指針（同樣指向任何我們想要指向的東西）。調(diào)用成功，返回0，出錯(cuò)時(shí)返回正Exxx值。Pthread函數(shù)不設(shè)置errno。
第二個(gè)函數(shù)：
int pthread_join(pthread_t tid,void ＊＊status);
該函數(shù)等待一個(gè)線程終止。把線程和進(jìn)程相比，pthread_creat類似于fork，而 pthread_join類似于waitpid。我們必須要等待線程的tid，很可惜，我們沒(méi)有辦法等待任意一個(gè)線程結(jié)束。如果status指針?lè)强?#xff0c;線程的返回值（一個(gè)指向某個(gè)對(duì)象的指針）將存放在status指向的位置。
第三個(gè)函數(shù)：
pthread_t pthread_self(void);
線程都有一個(gè)ID以在給定的進(jìn)程內(nèi)標(biāo)識(shí)自己。線程ID由pthread_creat返回，我們可以pthread_self取得自己的線程ID。
第四個(gè)函數(shù)：
int pthread_detach(pthread_t tid);
線程或者是可匯合的（joinable）或者是脫離的（detached）。當(dāng)可匯合的線程終止時(shí)，其線程ID和退出狀態(tài)將保留，直到另外一個(gè)線程調(diào)用pthread_join。脫離的線程則像守護(hù)進(jìn)程：當(dāng)它終止時(shí)，所有的資源都釋放，我們不能等待它終止。如果一個(gè)線程需要知道另一個(gè)線程什么時(shí)候終止，最好保留第二個(gè)線程的可匯合性。Pthread_detach函數(shù)將指定的線程變?yōu)槊撾x的。該函數(shù)通常被想脫離自己的線程調(diào)用，如：pthread_detach (pthread_self ( ));
第五個(gè)函數(shù)：
void pthread_exit(void ＊status);
該函數(shù)終止線程。如果線程未脫離，其線程ID和退出狀態(tài)將一直保留到調(diào)用進(jìn)程中的某個(gè)其他線程調(diào)用pthread_join函數(shù)。指針status不能指向局部于調(diào)用線程的對(duì)象，因?yàn)榫€程終止時(shí)這些對(duì)象也消失。有兩種其他方法可使線程終止：
啟動(dòng)線程的函數(shù)（pthread_creat的第3個(gè)參數(shù)）返回。既然該函數(shù)必須說(shuō)明為返回一個(gè)void指針，該返回值便是線程的終止?fàn)顟B(tài)。
如果進(jìn)程的main函數(shù)返回或者任何線程調(diào)用了exit，進(jìn)程將終止，線程將隨之終止。
一.pthread_create()之前的屬性設(shè)置
1．線程屬性設(shè)置
我們用pthread_create函數(shù)創(chuàng)建一個(gè)線程，在這個(gè)線程中，我們使用默認(rèn)參數(shù)，即將該函數(shù)的第二個(gè)參數(shù)設(shè)為NULL。的確，對(duì)大多數(shù)程序來(lái)說(shuō)，使用默認(rèn)屬性就夠了，但我們還是有必要來(lái)了解一下線程的有關(guān)屬性。
屬性結(jié)構(gòu)為pthread_attr_t，它同樣在頭文件pthread.h中定義，屬性值不能直接設(shè)置，須使用相關(guān)函數(shù)進(jìn)行操作，初始化的函數(shù)為pthread_attr_init，這個(gè)函數(shù)必須在pthread_create函數(shù)之前調(diào)用。屬性對(duì)象主要包括是否綁定、是否分離、
堆棧地址、堆棧大小、優(yōu)先級(jí)。默認(rèn)的屬性為非綁定、非分離、缺省的堆棧、與父進(jìn)程同樣級(jí)別的優(yōu)先級(jí)。
2．綁定
關(guān)于線程的綁定，牽涉到另外一個(gè)概念：輕進(jìn)程（LWP：Light Weight Process）。輕進(jìn)程可以理解為內(nèi)核線程，它位于用戶層和系統(tǒng)層之間。系統(tǒng)對(duì)線程資源的分配、對(duì)線程的控制是通過(guò)輕進(jìn)程來(lái)實(shí)現(xiàn)的，一個(gè)輕進(jìn)程可以控制一個(gè)或多個(gè)線程。默認(rèn)狀況下，啟動(dòng)多少輕進(jìn)程、哪些輕進(jìn)程來(lái)控制哪些線程是由系統(tǒng)來(lái)控制的，這種狀況即稱為非綁定的。綁定狀況下，則顧名思義，即某個(gè)線程固定的"綁"在一個(gè)輕進(jìn)程之上。被綁定的線程具有較高的響應(yīng)速度，這是因?yàn)镃PU時(shí)間片的調(diào)度是面向輕進(jìn)程的，綁定的線程可以保證在需要的時(shí)候它總有一個(gè)輕進(jìn)程可用。通過(guò)設(shè)置被綁定的輕進(jìn)程的優(yōu)先級(jí)和調(diào)度級(jí)可以使得綁定的線程滿足諸如實(shí)時(shí)反應(yīng)之類的要求。
設(shè)置線程綁定狀態(tài)的函數(shù)為 pthread_attr_setscope，它有兩個(gè)參數(shù)，第一個(gè)是指向?qū)傩越Y(jié)構(gòu)的指針，第二個(gè)是綁定類型，它有兩個(gè)取值： PTHREAD_SCOPE_SYSTEM（綁定的）和PTHREAD_SCOPE_PROCESS（非綁定的）。下面的代碼即創(chuàng)建了一個(gè)綁定的線程。
＃i nclude <pthread.h>
pthread_attr_t attr;
pthread_t tid;
/初始化屬性值，均設(shè)為默認(rèn)值/
pthread_attr_init(&attr);
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
pthread_create(&tid, &attr, (void *) my_function, NULL);
3．線程分離狀態(tài) 線程的分離狀態(tài)決定一個(gè)線程以什么樣的方式來(lái)終止自己。非分離的線程終止時(shí)，其線程ID和退出狀態(tài)將保留，直到另外一個(gè)線程調(diào)用 pthread_join.分離的線程在當(dāng)它終止時(shí)，所有的資源將釋放，我們不能等待它終止。 設(shè)置線程分離狀態(tài)的函數(shù)為 pthread_attr_setdetachstate（pthread_attr_t *attr, int detachstate）。第二個(gè)參數(shù)可選為PTHREAD_CREATE_DETACHED（分離線程）和 PTHREAD _CREATE_JOINABLE（非分離線程）。這里要注意的一點(diǎn)是，如果設(shè)置一個(gè)線程為分離線程，而這個(gè)線程運(yùn)行又非常快，它很可能在 pthread_create函數(shù)返回之前就終止了，它終止以后就可能將線程號(hào)和系統(tǒng)資源移交給其他的線程使用，這樣調(diào)用pthread_create的線程就得到了錯(cuò)誤的線程號(hào)。要避免這種情況可以采取一定的同步措施，最簡(jiǎn)單的方法之一是可以在被創(chuàng)建的線程里調(diào)用 pthread_cond_timewait函數(shù)，讓這個(gè)線程等待一會(huì)兒，留出足夠的時(shí)間讓函數(shù)pthread_create返回。設(shè)置一段等待時(shí)間，是在多線程編程里常用的方法。
4．優(yōu)先級(jí) 它存放在結(jié)構(gòu)sched_param中。用函數(shù)pthread_attr_getschedparam和函數(shù) pthread_attr_setschedparam進(jìn)行存放，一般說(shuō)來(lái)，我們總是先取優(yōu)先級(jí)，對(duì)取得的值修改后再存放回去。下面即是一段簡(jiǎn)單的例子。
＃i nclude <pthread.h>
＃i nclude <sched.h>
pthread_attr_t attr; pthread_t tid;
sched_param param;
int newprio=20;
/初始化屬性/
pthread_attr_init(&attr);
/設(shè)置優(yōu)先級(jí)/
pthread_attr_getschedparam(&attr, ¶m);
param.sched_priority=newprio;
pthread_attr_setschedparam(&attr, ¶m);
pthread_create(&tid, &attr, (void *)myfunction, myarg);
二．線程數(shù)據(jù)處理 和進(jìn)程相比，線程的最大優(yōu)點(diǎn)之一是數(shù)據(jù)的共享性，各個(gè)進(jìn)程共享父進(jìn)程處沿襲的數(shù)據(jù)段，可以方便的獲得、修改數(shù)據(jù)。但這也給多線程編程帶來(lái)了許多問(wèn)題。我們必須當(dāng)心有多個(gè)不同的進(jìn)程訪問(wèn)相同的變量。許多函數(shù)是不可重入的，即同時(shí)不能運(yùn)行一個(gè)函數(shù)的多個(gè)拷貝（除非使用不同的數(shù)據(jù)段）。在函數(shù)中聲明的靜態(tài)變量常常帶來(lái)問(wèn)題，函數(shù)的返回值也會(huì)有問(wèn)題。因?yàn)槿绻祷氐氖呛瘮?shù)內(nèi)部靜態(tài)聲明的空間的地址，則在一個(gè)線程調(diào)用該函數(shù)得到地址后使用該地址指向的數(shù)據(jù)時(shí)，別的線程可能調(diào)用此函數(shù)并修改了這一段數(shù)據(jù)。在進(jìn)程中共享的變量必須用關(guān)鍵字volatile來(lái)定義，這是為了防止編譯器在優(yōu)化時(shí)（如gcc中使用-OX參數(shù)）改變它們的使用方式。為了保護(hù)變量，我們必須使用信號(hào)量、互斥等方法來(lái)保證我們對(duì)變量的正確使用。
1．線程數(shù)據(jù) 在單線程的程序里，有兩種基本的數(shù)據(jù)：全局變量和局部變量。但在多線程程序里，還有第三種數(shù)據(jù)類型：線程數(shù)據(jù)（TSD: Thread-Specific Data）。它和全局變量很象，在線程內(nèi)部，各個(gè)函數(shù)可以象使用全局變量一樣調(diào)用它，但它對(duì)線程外部的其它線程是不可見(jiàn)的。例如我們常見(jiàn)的變量 errno，它返回標(biāo)準(zhǔn)的出錯(cuò)信息。它顯然不能是一個(gè)局部變量，幾乎每個(gè)函數(shù)都應(yīng)該可以調(diào)用它；但它又不能是一個(gè)全局變量，否則在 A線程里輸出的很可能是B線程的出錯(cuò)信息。要實(shí)現(xiàn)諸如此類的變量，我們就必須使用線程數(shù)據(jù)。我們?yōu)槊總€(gè)線程數(shù)據(jù)創(chuàng)建一個(gè)鍵，它和這個(gè)鍵相關(guān)聯(lián)，在各個(gè)線程里，都使用這個(gè)鍵來(lái)指代線程數(shù)據(jù)，但在不同的線程里，這個(gè)鍵代表的數(shù)據(jù)是不同的，在同一個(gè)線程里，它代表同樣的數(shù)據(jù)內(nèi)容。
和線程數(shù)據(jù)相關(guān)的函數(shù)主要有4個(gè)：創(chuàng)建一個(gè)鍵；為一個(gè)鍵指定線程數(shù)據(jù)；從一個(gè)鍵讀取線程數(shù)據(jù)；刪除鍵。
創(chuàng)建鍵的函數(shù)原型為：
int pthread_key_create __P ((pthread_key_t *__key,void (*__destr_function) (void ))); 第一個(gè)參數(shù)為指向一個(gè)鍵值的指針，第二個(gè)參數(shù)指明了一個(gè)destructor函數(shù)，如果這個(gè)參數(shù)不為空，那么當(dāng)每個(gè)線程結(jié)束時(shí)，系統(tǒng)將調(diào)用這個(gè)函數(shù)來(lái)釋放綁定在這個(gè)鍵上的內(nèi)存塊。這個(gè)函數(shù)常和函數(shù)pthread_once ((pthread_once_tonce_control, void (initroutine) (void)))一起使用，為了讓這個(gè)鍵只被創(chuàng)建一次。函數(shù)pthread_once聲明一個(gè)初始化函數(shù)，第一次調(diào)用pthread_once時(shí)它執(zhí)行這個(gè)函數(shù)，以后的調(diào)用將被它忽略。
int pthread_key_delete(pthread_key_t key);
該函數(shù)用于刪除一個(gè)由pthread_key_create 函數(shù)調(diào)用創(chuàng)建的鍵。調(diào)用成功返回值為0，否則返回錯(cuò)誤代碼。
在下面的例子中，我們創(chuàng)建一個(gè)鍵，并將它和某個(gè)數(shù)據(jù)相關(guān)聯(lián)。我們要定義一個(gè)函數(shù) createWindow，這個(gè)函數(shù)定義一個(gè)圖形窗口（數(shù)據(jù)類型為Fl_Window ，這是圖形界面開(kāi)發(fā)工具FLTK中的數(shù)據(jù)類型）。由于各個(gè)線程都會(huì)調(diào)用這個(gè)函數(shù)，所以我們使用線程數(shù)據(jù)。
/ 聲明一個(gè)鍵/
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指向一個(gè)新建立的窗口/
win=new Fl_Window( 0, 0, 100, 100, "MyWindow");
/ 對(duì)此窗口作一些可能的設(shè)置工作，如大小、位置、名稱等/
setWindow(win);
/ 將窗口指針值綁定在鍵myWinKey上/
pthread_setpecific ( myWinKey, win);
}
/ 函數(shù) createMyKey，創(chuàng)建一個(gè)鍵，并指定了destructor /
void createMyKey ( void ) {
pthread_keycreate(&myWinKey, freeWinKey);
}
/ 函數(shù) freeWinKey，釋放空間/
void freeWinKey ( Fl_Window win){
delete win;
}
這樣，在不同的線程中調(diào)用函數(shù)createMyWin，都可以得到在線程內(nèi)部均可見(jiàn)的窗口變量，這個(gè)變量通過(guò)函數(shù) pthread_getspecific得到。在上面的例子中，我們已經(jīng)使用了函數(shù)pthread_setspecific來(lái)將線程數(shù)據(jù)和一個(gè)鍵綁定在一起。這兩個(gè)函數(shù)的原型如下：
int pthread_setspecific __P ((pthread_key_t __key,__const void *__pointer)); 該函數(shù)設(shè)置一個(gè)線程專有數(shù)據(jù)的值，賦給由pthread_key_create 創(chuàng)建的鍵，調(diào)用成功返回值為0，否則返回錯(cuò)誤代碼。
void *pthread_getspecific __P ((pthread_key_t __key)); 該函數(shù)獲得綁定到指定鍵上的值。調(diào)用成功，返回給定參數(shù)key 所對(duì)應(yīng)的數(shù)據(jù)。如果沒(méi)有數(shù)據(jù)連接到該鍵，則返回NULL。
這兩個(gè)函數(shù)的參數(shù)意義和使用方法是顯而易見(jiàn)的。要注意的是，用pthread_setspecific為一個(gè)鍵指定新的線程數(shù)據(jù)時(shí)，必須自己釋放原有的線程數(shù)據(jù)以回收空間。這個(gè)過(guò)程函數(shù)pthread_key_delete用來(lái)刪除一個(gè)鍵，這個(gè)鍵占用的內(nèi)存將被釋放，但同樣要注意的是，它只釋放鍵占用的內(nèi)存，并不釋放該鍵關(guān)聯(lián)的線程數(shù)據(jù)所占用的內(nèi)存資源，而且它也不會(huì)觸發(fā)函數(shù)pthread_key_create中定義的destructor函數(shù)。線程數(shù)據(jù)的釋放必須在釋放鍵之前完成。
2．互斥鎖 假設(shè)各個(gè)現(xiàn)成向同一個(gè)文件順序?qū)懭霐?shù)據(jù)，最后得到的結(jié)果是不可想象的。所以用互斥鎖來(lái)保證一段時(shí)間內(nèi)只有一個(gè)線程在執(zhí)行一段代碼。
使用int pthread_mutex_lock鎖住互斥鎖，使用int pthread_mutex_unlock解瑣。
如果我們?cè)噲D為一個(gè)已被其他線程鎖住的互斥鎖加鎖，程序便會(huì)阻塞直到該互斥對(duì)象解鎖。
如果在共享內(nèi)存中分配一個(gè)互斥鎖，我們必須在運(yùn)行時(shí)調(diào)用ptgread_mutex_init函數(shù)盡心初始化。
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;
/* 定義延遲時(shí)間/
delay.tv_sec = 2;
delay.tv_nec = 0;
/ 用默認(rèn)屬性初始化一個(gè)互斥鎖對(duì)象/
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;
}
/ 打開(kāi)互斥鎖*/
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);
}
}
函數(shù) pthread_mutex_init用來(lái)生成一個(gè)互斥鎖。NULL參數(shù)表明使用默認(rèn)屬性。如果需要聲明特定屬性的互斥鎖，須調(diào)用函數(shù) pthread_mutexattr_init。函數(shù)pthread_mutexattr_setpshared和函數(shù) pthread_mutexattr_settype用來(lái)設(shè)置互斥鎖屬性。前一個(gè)函數(shù)設(shè)置屬性pshared，它有兩個(gè)取值， PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用來(lái)不同進(jìn)程中的線程同步，后者用于同步本進(jìn)程的不同線程。在上面的例子中，我們使用的是默認(rèn)屬性PTHREAD_PROCESS_ PRIVATE。后者用來(lái)設(shè)置互斥鎖類型，可選的類型有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、 PTHREAD_MUTEX_RECURSIVE和PTHREAD _MUTEX_DEFAULT。它們分別定義了不同的上所、解鎖機(jī)制，一般情況下，選用最后一個(gè)默認(rèn)屬性。
需要注意的是在使用互斥鎖的過(guò)程中很有可能會(huì)出現(xiàn)死鎖：兩個(gè)線程試圖同時(shí)占用兩個(gè)資源，并按不同的次序鎖定相應(yīng)的互斥鎖，例如兩個(gè)線程都需要鎖定互斥鎖1和互斥鎖2，a線程先鎖定互斥鎖1，b 線程先鎖定互斥鎖2，這時(shí)就出現(xiàn)了死鎖。此時(shí)我們可以使用函數(shù) pthread_mutex_trylock，它是函數(shù)pthread_mutex_lock的非阻塞版本，當(dāng)它發(fā)現(xiàn)死鎖不可避免時(shí)，它會(huì)返回相應(yīng)的信息，程序員可以針對(duì)死鎖做出相應(yīng)的處理。另外不同的互斥鎖類型對(duì)死鎖的處理不一樣，但最主要的還是要程序員自己在程序設(shè)計(jì)注意這一點(diǎn)。
3．條件變量
互斥鎖一個(gè)明顯的缺點(diǎn)是它只有兩種狀態(tài)：鎖定和非鎖定。而條件變量通過(guò)允許線程阻塞和等待另一個(gè)線程發(fā)送信號(hào)的方法彌補(bǔ)了互斥鎖的不足，它常和互斥鎖一起使用。使用時(shí)，條件變量被用來(lái)阻塞一個(gè)線程，當(dāng)條件不滿足時(shí)，線程往往解開(kāi)相應(yīng)的互斥鎖并等待條件發(fā)生變化。一旦其它的某個(gè)線程改變了條件變量，它將通知相應(yīng)的條件變量喚醒一個(gè)或多個(gè)正被此條件變量阻塞的線程。這些線程將重新鎖定互斥鎖并重新測(cè)試條件是否滿足。一般說(shuō)來(lái)，條件變量被用來(lái)進(jìn)行線承間的同步。
條件變量的結(jié)構(gòu)為pthread_cond_t，函數(shù)pthread_cond_init（）被用來(lái)初始化一個(gè)條件變量。它的原型為：
int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));
其中cond是一個(gè)指向結(jié)構(gòu)pthread_cond_t的指針，cond_attr是一個(gè)指向結(jié)構(gòu)pthread_condattr_t的指針。結(jié)構(gòu) pthread_condattr_t是條件變量的屬性結(jié)構(gòu)，和互斥鎖一樣我們可以用它來(lái)設(shè)置條件變量是進(jìn)程內(nèi)可用還是進(jìn)程間可用，默認(rèn)值是 PTHREAD_ PROCESS_PRIVATE，即此條件變量被同一進(jìn)程內(nèi)的各個(gè)線程使用。注意初始化條件變量只有未被使用時(shí)才能重新初始化或被釋放。
在pthread中，條件變量是一個(gè)pthread_cond_t類型的變量，條件變量使用下面兩個(gè)函數(shù)：
pthread_cond_wait 函數(shù)用于阻塞，線程可以被函數(shù)pthread_cond_signal和函數(shù) pthread_cond_broadcast喚醒，但是要注意的是，條件變量只是起阻塞和喚醒線程的作用，具體的判斷條件還需用戶給出，例如一個(gè)變量是否為0等等，這一點(diǎn)我們從后面的例子中可以看到。線程被喚醒后，它將重新檢查判斷條件是否滿足，如果還不滿足，一般說(shuō)來(lái)線程應(yīng)該仍阻塞在這里，被等待被下一次喚醒。這個(gè)過(guò)程一般用while語(yǔ)句實(shí)現(xiàn)。
另一個(gè)用來(lái)阻塞線程的函數(shù)是pthread_cond_timedwait（）它比函數(shù)pthread_cond_wait（）多了一個(gè)時(shí)間參數(shù)，經(jīng)歷abstime段時(shí)間后，即使條件變量不滿足，阻塞也被解除。
函數(shù)pthread_cond_signal（）用來(lái)釋放被阻塞在條件變量cond上的一個(gè)線程。
函數(shù)pthread_cond_broadcast（pthread_cond_t *cond）用來(lái)喚醒所有被阻塞在條件變量cond上的線程。這些線程被喚醒后將再次競(jìng)爭(zhēng)相應(yīng)的互斥鎖，所以必須小心使用這個(gè)函數(shù)。
下面是使用函數(shù)pthread_cond_wait（）和函數(shù)pthread_cond_signal（）的一個(gè)簡(jiǎn)單的例子:
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時(shí)， decrement函數(shù)在pthread_cond_wait處被阻塞，并打開(kāi)互斥鎖count_lock。此時(shí)，當(dāng)調(diào)用到函數(shù) increment_count時(shí)，pthread_cond_signal（）函數(shù)改變條件變量，告知decrement_count（）停止阻塞。
=================================================================================
pthread_mutex_lock
函數(shù)名
pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock - lock and unlock a mutex
SYNOPSIS
概要
include <pthread.h>
int pthread_mutex_lock(pthread_mutex_t *
mutex
);
int pthread_mutex_trylock(pthread_mutex_t *
mutex
);
int pthread_mutex_unlock(pthread_mutex_t *
mutex
);
描述
pthread_mutex_lock()函數(shù)鎖住由mutex指定的mutex 對(duì)象。如果mutex已經(jīng)被鎖住，調(diào)用這個(gè)函數(shù)的線程阻塞直到mutex可用為止。這跟函數(shù)返回的時(shí)候參數(shù)mutex指定的mutex對(duì)象變成鎖住狀態(tài)，同時(shí)該函數(shù)的調(diào)用線程成為該mutex對(duì)象的擁有者。
如果mutex 對(duì)象的type是 PTHREAD_MUTEX_NORMAL，不進(jìn)行deadlock detection(死鎖檢測(cè))。企圖進(jìn)行relock 這個(gè)mutex會(huì)導(dǎo)致deadlock. 如果一個(gè)線程對(duì)未加鎖的或已經(jīng)unlock的mutex對(duì)象進(jìn)行unlock操作，結(jié)果是不未知的。
如果mutex類型是 PTHREAD_MUTEX_ERRORCHECK，那么將進(jìn)行錯(cuò)誤檢查。如果一個(gè)線程企圖對(duì)一個(gè)已經(jīng)鎖住的mutex進(jìn)行relock，將返回一個(gè)錯(cuò)誤。如果一個(gè)線程對(duì)未加鎖的或已經(jīng)unlock的mutex對(duì)象進(jìn)行unlock操作，將返回一個(gè)錯(cuò)誤。
如果mutex類型是 PTHREAD_MUTEX_RECURSIVE，mutex會(huì)有一個(gè)鎖住次數(shù)（lock count）的概念。當(dāng)一個(gè)線程成功地第一次鎖住一個(gè)mutex的時(shí)候，鎖住次數(shù)（lock count）被設(shè)置為1，每一次一個(gè)線程unlock這個(gè)mutex的時(shí)候，鎖住次數(shù)（lock count）就減1。當(dāng)鎖住次數(shù)（lock count）減少為0的時(shí)候，其他線程就能獲得該mutex鎖了。如果一個(gè)線程對(duì)未加鎖的或已經(jīng)unlock的mutex對(duì)象進(jìn)行unlock操作，將返回一個(gè)錯(cuò)誤。
如果mutex類型是 PTHREAD_MUTEX_DEFAULT，企圖遞歸的獲取這個(gè)mutex的鎖的結(jié)果是不確定的。unlock一個(gè)不是被調(diào)用線程鎖住的mutex的結(jié)果也是不確定的。企圖unlock一個(gè)未被鎖住的mutex導(dǎo)致不確定的結(jié)果。
pthread_mutex_trylock()調(diào)用在參數(shù)mutex指定的mutex對(duì)象當(dāng)前被鎖住的時(shí)候立即返回，除此之外，pthread_mutex_trylock()跟pthread_mutex_lock()功能完全一樣。
The pthread_mutex_unlock()函數(shù)釋放有參數(shù)mutex指定的mutex對(duì)象的鎖。如果被釋放取決于該Mutex對(duì)象的類型屬性。如果有多個(gè)線程為了獲得該mutex鎖阻塞，調(diào)用pthread_mutex_unlock()將是該mutex可用，一定的調(diào)度策略將被用來(lái)決定哪個(gè)線程可以獲得該mutex鎖。（在mutex類型為PTHREAD_MUTEX_RECURSIVE 的情況下，只有當(dāng)lock count 減為0并且調(diào)用線程在該mutex上已經(jīng)沒(méi)有鎖的時(shí)候）（翻譯到這里，才覺(jué)得我的這個(gè)鎖概念是多么模糊）
如果一個(gè)線程在等待一個(gè)mutex鎖得時(shí)候收到了一個(gè)signal,那么在從signal handler返回的時(shí)候，該線程繼續(xù)等待該mutex鎖，就像這個(gè)線程沒(méi)有被中斷一樣。
返回值
成功，pthread_mutex_lock() 和 pthread_mutex_unlock() 返回0，否則返回一個(gè)錯(cuò)誤的提示碼
pthread_mutex_trylock() 在成功獲得了一個(gè)mutex的鎖后返回0，否則返回一個(gè)錯(cuò)誤提示碼
錯(cuò)誤
pthread_mutex_lock() 和 pthread_mutex_unlock()失敗的時(shí)候
[EINVAL]
mutex在生成的時(shí)候，它的protocol屬性的值是 PTHREAD_PRIO_PROTECT，同時(shí)調(diào)用線程的優(yōu)先級(jí)(priority)比該mutex的當(dāng)前prority上限高
pthread_mutex_trylock() 函數(shù)在一下情況會(huì)失敗：
[EBUSY]
The mutex could not be acquired because it was already locked.
mutex已經(jīng)被鎖住的時(shí)候無(wú)法再獲取鎖
The pthread_mutex_lock(), pthread_mutex_trylock() and pthread_mutex_unlock() functions may fail if:
[EINVAL]
mutex指向的mutex未被初始化
[EAGAIN]
Mutex的lock count(鎖數(shù)量)已經(jīng)超過(guò) 遞歸索的最大值，無(wú)法再獲得該mutex鎖
pthread_mutex_lock() 函數(shù)在一下情況下會(huì)失敗：
[EDEADLK]
當(dāng)前線程已經(jīng)獲得該mutex鎖
pthread_mutex_unlock() 函數(shù)在以下情況下會(huì)失敗：
[EPERM]
當(dāng)前線程不是該mutex鎖的擁有者
所有的這些函數(shù)的錯(cuò)誤返回值都不會(huì)是[EINTR]
=================================================================================
pthread_join函數(shù)及l(fā)inux線程
pthread_join使一個(gè)線程等待另一個(gè)線程結(jié)束。
代碼中如果沒(méi)有pthread_join主線程會(huì)很快結(jié)束從而使整個(gè)進(jìn)程結(jié)束，從而使創(chuàng)建的線程沒(méi)有機(jī)會(huì)開(kāi)始執(zhí)行就結(jié)束了。加入pthread_join后，主線程會(huì)一直等待直到等待的線程結(jié)束自己才結(jié)束，使創(chuàng)建的線程有機(jī)會(huì)執(zhí)行。
所有線程都有一個(gè)線程號(hào)，也就是Thread ID。其類型為pthread_t。通過(guò)調(diào)用pthread_self()函數(shù)可以獲得自身的線程號(hào)。
下面說(shuō)一下如何創(chuàng)建一個(gè)線程。
通過(guò)創(chuàng)建線程，線程將會(huì)執(zhí)行一個(gè)線程函數(shù)，該線程格式必須按照下面來(lái)聲明：
void * Thread_Function(void *)創(chuàng)建線程的函數(shù)如下：
int pthread_create(pthread_t *restrict thread,const pthread_attr_t *restrict attr,void *(*start_routine)(void*), void *restrict arg);下面說(shuō)明一下各個(gè)參數(shù)的含義：
thread：所創(chuàng)建的線程號(hào)。
attr：所創(chuàng)建的線程屬性，這個(gè)將在后面詳細(xì)說(shuō)明。
start_routine：即將運(yùn)行的線程函數(shù)。
art：傳遞給線程函數(shù)的參數(shù)。
下面是一個(gè)簡(jiǎn)單的創(chuàng)建線程例子：
include <pthread.h>
include <stdio.h>
/* Prints x’s to stderr. The parameter is unused. Does not return. */
void* print_xs (void* unused)
{
while (1)
fputc (‘x’, stderr);
return NULL;
}
/* The main program. */
int main ()
{
pthread_t thread_id;
/* Create a new thread. The new thread will run the print_xs
function. */
pthread_create (&thread_id, NULL, &print_xs, NULL);
/* Print o’s continuously to stderr. */
while (1)
fputc (‘o’, stderr);
return 0;
}
在編譯的時(shí)候需要注意，由于線程創(chuàng)建函數(shù)在libpthread.so庫(kù)中，所以在編譯命令中需要將該庫(kù)導(dǎo)入。命令如下：
gcc –o createthread –lpthread createthread.c
如果想傳遞參數(shù)給線程函數(shù)，可以通過(guò)其參數(shù)arg，其類型是void 。如果你需要傳遞多個(gè)參數(shù)的話，可以考慮將這些參數(shù)組成一個(gè)結(jié)構(gòu)體來(lái)傳遞。另外，由于類型是void ，所以你的參數(shù)不可以被提前釋放掉。
下面一個(gè)問(wèn)題和前面創(chuàng)建進(jìn)程類似，不過(guò)帶來(lái)的問(wèn)題回避進(jìn)程要嚴(yán)重得多。如果你的主線程，也就是main函數(shù)執(zhí)行的那個(gè)線程，在你其他縣城推出之前就已經(jīng)退出，那么帶來(lái)的bug則不可估量。通過(guò)pthread_join函數(shù)會(huì)讓主線程阻塞，直到所有線程都已經(jīng)退出。
int pthread_join(pthread_t thread, void **value_ptr);
thread：等待退出線程的線程號(hào)。
value_ptr：退出線程的返回值。
下面一個(gè)例子結(jié)合上面的內(nèi)容：
int main ()
{
pthread_t thread1_id;
pthread_t thread2_id;
struct char_print_parms thread1_args;
struct char_print_parms thread2_args;
/* Create a new thread to print 30,000 x’s. */
thread1_args.character = ’x’;
thread1_args.count = 30000;
pthread_create (&thread1_id, NULL, &char_print, &thread1_args);
/* Create a new thread to print 20,000 o’s. */
thread2_args.character = ’o’;
thread2_args.count = 20000;
pthread_create (&thread2_id, NULL, &char_print, &thread2_args);
/* Make sure the first thread has finished. */
pthread_join (thread1_id, NULL);
/* Make sure the second thread has finished. */
pthread_join (thread2_id, NULL);
/* Now we can safely return. */
return 0;
}
下面說(shuō)一下前面提到的線程屬性。
在我們前面提到，可以通過(guò)pthread_join()函數(shù)來(lái)使主線程阻塞等待其他線程退出，這樣主線程可以清理其他線程的環(huán)境。但是還有一些線程，更喜歡自己來(lái)清理退出的狀態(tài)，他們也不愿意主線程調(diào)用pthread_join來(lái)等待他們。我們將這一類線程的屬性稱為detached。如果我們?cè)谡{(diào)用pthread_create()函數(shù)的時(shí)候?qū)傩栽O(shè)置為NULL，則表明我們希望所創(chuàng)建的線程采用默認(rèn)的屬性，也就是jionable。如果需要將屬性設(shè)置為detached，則參考下面的例子：
include <stdio.h>
include <pthread.h>
void * start_run(void * arg)
{
//do some work}
int main()
{
pthread_t thread_id;pthread_attr_t attr;pthread_attr_init(&attr);pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED);pthread_create(&thread_id,&attr,start_run,NULL);pthread_attr_destroy(&attr);sleep(5);exit(0);}
在線程設(shè)置為joinable后，可以調(diào)用pthread_detach()使之成為detached。但是相反的操作則不可以。還有，如果線程已經(jīng)調(diào)用pthread_join()后，則再調(diào)用pthread_detach()則不會(huì)有任何效果。
線程可以通過(guò)自身執(zhí)行結(jié)束來(lái)結(jié)束，也可以通過(guò)調(diào)用pthread_exit()來(lái)結(jié)束線程的執(zhí)行。另外，線程甲可以被線程乙被動(dòng)結(jié)束。這個(gè)通過(guò)調(diào)用pthread_cancel()來(lái)達(dá)到目的。
int pthread_cancel(pthread_t thread);
函數(shù)調(diào)用成功返回0。當(dāng)然，線程也不是被動(dòng)的被別人結(jié)束。它可以通過(guò)設(shè)置自身的屬性來(lái)決定如何結(jié)束。
線程的被動(dòng)結(jié)束分為兩種，一種是異步終結(jié)，另外一種是同步終結(jié)。異步終結(jié)就是當(dāng)其他線程調(diào)用 pthread_cancel的時(shí)候，線程就立刻被結(jié)束。而同步終結(jié)則不會(huì)立刻終結(jié)，它會(huì)繼續(xù)運(yùn)行，直到到達(dá)下一個(gè)結(jié)束點(diǎn)（cancellation point）。當(dāng)一個(gè)線程被按照默認(rèn)的創(chuàng)建方式創(chuàng)建，那么它的屬性是同步終結(jié)。
通過(guò)調(diào)用pthread_setcanceltype()來(lái)設(shè)置終結(jié)狀態(tài)。
int pthread_setcanceltype(int type, int *oldtype);
state：要設(shè)置的狀態(tài)，可以為PTHREAD_CANCEL_DEFERRED或者為PTHREAD_CANCEL_ASYNCHRONOUS。
那么前面提到的結(jié)束點(diǎn)又是如何設(shè)置了？最常用的創(chuàng)建終結(jié)點(diǎn)就是調(diào)用pthread_testcancel()的地方。該函數(shù)除了檢查同步終結(jié)時(shí)的狀態(tài)，其他什么也不做。
上面一個(gè)函數(shù)是用來(lái)設(shè)置終結(jié)狀態(tài)的。還可以通過(guò)下面的函數(shù)來(lái)設(shè)置終結(jié)類型，即該線程可不可以被終結(jié)：
int pthread_setcancelstate(int state, int *oldstate);
state：終結(jié)狀態(tài)，可以為PTHREAD_CANCEL_DISABLE或者PTHREAD_CANCEL_ENABLE。具體什么含義大家可以通過(guò)單詞意思即可明白。最后說(shuō)一下線程的本質(zhì)。其實(shí)在Linux中，新建的線程并不是在原先的進(jìn)程中，而是系統(tǒng)通過(guò)一個(gè)系統(tǒng)調(diào)用clone()。該系統(tǒng)copy了一個(gè)和原先進(jìn)程完全一樣的進(jìn)程，并在這個(gè)進(jìn)程中執(zhí)行線程函數(shù)。不過(guò)這個(gè)copy過(guò)程和fork不一樣。 copy后的進(jìn)程和原先的進(jìn)程共享了所有的變量，運(yùn)行環(huán)境。這樣，原先進(jìn)程中的變量變動(dòng)在copy后的進(jìn)程中便能體現(xiàn)出來(lái)。
clone的fork與pthread_create創(chuàng)建線程有何不同&pthread多線程編程的學(xué)習(xí)小結(jié) - rock_joker的博客 - CSDN博客 https://blog.csdn.net/rock_joker/article/details/72722008
轉(zhuǎn)載于:https://www.cnblogs.com/tongongV/p/10668698.html
總結(jié)
以上是生活随笔為你收集整理的clone的fork与pthread_create创建线程有何不同pthread多线程编程的学习小结(转)的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問(wèn)題。
- 上一篇： 将DBF文件导入Sqlserver数据库
- 下一篇： 原生js增加或者删除class