clone的fork与pthread_create创建线程有何不同pthread多线程编程的学习小结
?進程是一個指令執行流及其執行環境，其執行環境是一個系統資源的集合，這些資源在Linux中被抽
象成各種數據對象：進程控制塊、虛存空間、文件系統，文件I/O、信號處理函數。所以創建一個進程的
過程就是這些數據對象的創建過程。
? 在調用系統調用fork創建一個進程時，子進程只是完全復制父進程的資源，這樣得到的子進程獨立于
父進程，具有良好的并發性，但是二者之間的通訊需要通過專門的通訊機制，如：pipe，fifo，System V
IPC機制等，另外通過fork創建子進程系統開銷很大，需要將上面描述的每種資源都復制一個副本。這樣
看來，fork是一個開銷十分大的系統調用，這些開銷并不是所有的情況下都是必須的，比如某進程fork出
一個子進程后，其子進程僅僅是為了調用exec執行另一個執行文件，那么在fork過程中對于虛存空間的復
制將是一個多余的過程（由于linux中是采取了copy-on-write技術，所以這一步驟的所做的工作只是虛存
管理部分的復制以及頁表的創建，而并沒有包括物理也面的拷貝）；另外，有時一個進程中具有幾個獨立
的計算單元，可以在相同的地址空間上基本無沖突進行運算，但是為了把這些計算單元分配到不同的處理
器上，需要創建幾個子進程，然后各個子進程分別計算最后通過一定的進程間通訊和同步機制把計算結果
匯總，這樣做往往有許多格外的開銷，而且這種開銷有時足以抵消并行計算帶來的好處。
另?進程是系統中程序執行和資源分配的基本單位。每個進程都擁有自己的
數據段、代碼段和堆棧段，這就造成了進程在進行切換等操作時都需要有比較負責的上下文
切換等動作。為了進一步減少處理機的空轉時間支持多處理器和減少上下文切換開銷
??這說明了把計算單元抽象到進程上是不充分的，這也就是許多系統中都引入了線程的概念的原因。在
講述線程前首先介紹以下vfork系統調用，vfork系統調用不同于fork，用vfork創建的子進程共享地址空
間，也就是說子進程完全運行在父進程的地址空間上，子進程對虛擬地址空間任何數據的修改同樣為父進
程所見。但是用vfork創建子進程后，父進程會被阻塞直到子進程調用exec或exit。這樣的好處是在子進
程被創建后僅僅是為了調用exec執行另一個程序時，因為它就不會對父進程的地址空間有任何引用，所以
對地址空間的復制是多余的，通過vfork可以減少不必要的開銷。
? 在Linux中， fork和vfork都是調用同一個核心函數
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
等等標志位，任何一位被置1了則表明創建的子進程和父進程共享該位對應的資源。所以在vfork的實現中
，cloneflags = CLONE_VFORK | CLONE_VM |SIGCHLD，這表示子進程和父進程共享地址空間，同時
do_fork會檢查CLONE_VFORK，如果該位被置1了，子進程會把父進程的地址空間鎖住，直到子進程退出或
執行exec時才釋放該鎖。
?
在講述clone系統調用前先簡單介紹線程的一些概念。
線程是在進程的基礎上進一步的抽象，也就是說一個進程分為兩個部分：線程集合和資源集合。線程
是進程中的一個動態對象，它應該是一組獨立的指令流，進程中的所有線程將共享進程里的資源。但是線
程應該有自己的私有對象：比如程序計數器、堆棧和寄存器上下文。
線程分為三種類型：
內核線程、輕量級進程和用戶線程。
內核線程：
它的創建和撤消是由內核的內部需求來決定的，用來負責執行一個指定的函數，一個內核線程不需要
和一個用戶進程聯系起來。它共享內核的正文段核全局數據，具有自己的內核堆棧。它能夠單獨的被調度
并且使用標準的內核同步機制，可以被單獨的分配到一個處理器上運行。內核線程的調度由于不需要經過
態的轉換并進行地址空間的重新映射，因此在內核線程間做上下文切換比在進程間做上下文切換快得多。
輕量級進程：
輕量級進程是核心支持的用戶線程，它在一個單獨的進程中提供多線程控制。這些輕量級進程被單獨
的調度，可以在多個處理器上運行，每一個輕量級進程都被綁定在一個內核線程上，而且在它的生命周期
這種綁定都是有效的。輕量級進程被獨立調度并且共享地址空間和進程中的其它資源，但是每個LWP都應
該有自己的程序計數器、寄存器集合、核心棧和用戶棧。
用戶線程：
用戶線程是通過線程庫實現的。它們可以在沒有內核參與下創建、釋放和管理。線程庫提供了同步和
調度的方法。這樣進程可以使用大量的線程而不消耗內核資源，而且省去大量的系統開銷。用戶線程的實
現是可能的，因為用戶線程的上下文可以在沒有內核干預的情況下保存和恢復。每個用戶線程都可以有自
己的用戶堆棧，一塊用來保存用戶級寄存器上下文以及如信號屏蔽等狀態信息的內存區。庫通過保存當前
線程的堆棧和寄存器內容載入新調度線程的那些內容來實現用戶線程之間的調度和上下文切換。
內核仍然負責進程的切換，因為只有內核具有修改內存管理寄存器的權力。用戶線程不是真正的調度
實體，內核對它們一無所知，而只是調度用戶線程下的進程或者輕量級進程，這些進程再通過線程庫函數
來調度它們的線程。當一個進程被搶占時，它的所有用戶線程都被搶占，當一個用戶線程被阻塞時，它會
阻塞下面的輕量級進程，如果進程只有一個輕量級進程，則它的所有用戶線程都會被阻塞。
?
明確了這些概念后，來講述Linux的線程和clone系統調用。
在許多實現了MT的操作系統中（如：Solaris，Digital Unix等）， 線程和進程通過兩種數據結構來
抽象表示： 進程表項和線程表項，一個進程表項可以指向若干個線程表項， 調度器在進程的時間片內再
調度線程。 但是在Linux中沒有做這種區分， 而是統一使用task_struct來管理所有進程/線程，只是
線程與線程之間的資源是共享的，這些資源可是是前面提到過的：虛存、文件系統、文件I/O以及信號處
理函數甚至PID中的幾種。
也就是說Linux中，每個線程都有一個task_struct，所以線程和進程可以使用同一調度器調度。其實
Linux核心中，輕量級進程和進程沒有質上的差別，因為Linux中進程的概念已經被抽象成了計算狀態加資
源的集合，這些資源在進程間可以共享。如果一個task獨占所有的資源，則是一個HWP，如果一個task和
其它task共享部分資源，則是LWP。
clone系統調用就是一個創建輕量級進程的系統調用：
int clone(int (*fn)(void * arg), void *stack, int flags, void *arg);
其中fn是輕量級進程所執行的過程，stack是輕量級進程所使用的堆棧，flags可以是前面提到的
CLONE_VM, CLONE_FS, CLONE_FILES, CLONE_SIGHAND,CLONE_PID的組合。Clone和fork，vfork在實現時
都是調用核心函數do_fork。
do_fork(unsigned long clone_flag, unsigned long usp, structpt_regs)；
和fork、vfork不同的是，fork時clone_flag = SIGCHLD；
vfork時clone_flag = CLONE_VM | CLONE_VFORK | SIGCHLD；
而在clone中，clone_flag由用戶給出。
下面給出一個使用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);
??? .. . . . .
}
看起來clone的用法和pthread_create有些相似，兩者的最根本的差別在于clone是創建一個LWP，對
核心是可見的，由核心調度，而pthread_create通常只是創建一個用戶線程，對核心是不可見的，由線程
庫調度。
linux的pthread_create最終調用clone,pthread_create調用clone,并把開辟一個stack作為參數
thread 建立, 同步,銷毀等由線程庫負責,
pthread多線程編程整理
?
1 Introduction 不用介紹了吧… 2 Thread Concepts 1.?????Thread由下面部分組成： a.?????Thread ID b.?????Stack c.?????Policy d.?????Signal mask e.?????Errno f.??????Thread-Specific Data 3 Thread Identification 1.?????pthread_t用于表示Thread ID，具體內容根據實現的不同而不同，有可能是一個Structure，因此不能將其看作為整數 2.?????pthread_equal函數用于比較兩個pthread_t是否相等
| ＃i nclude <pthread.h> int pthread_equal(pthread_t tid1, pthread_t tid2) |
| ＃i nclude <pthread.h> pthread _t pthread_self(void); |
| ＃i nclude <pthread.h> int pthread_create( ?????? pthread_t *restrict tidp, ?????? const pthread_attr_t *restrict attr, ?????? void *(*start_rtn)(void *), void *restrict arg); |
| ＃i nclude <pthread.h> void pthread_exit(void *rval_ptr); int pthread_join(pthread_t thread, void **rval_ptr); |
| ＃i nclude <pthread.h> void pthread_cancel(pthread_t tid) |
| ＃i nclude <pthread.h> void pthread_cleanup_push(void (*rtn)(void *), void *arg); void pthread_cleanup_pop(int execute); |
| void *thread_func(void *arg) { ??? pthread_cleanup_push(cleanup, “handler”) ??? // do something ??? Pthread_cleanup_pop(0); ??? return((void *)0)； } |
| Process Primitive | Thread Primitive | Description |
| fork | pthread_create | 創建新的控制流 |
| exit | pthread_exit | 退出已有的控制流 |
| waitpid | pthread_join | 等待控制流并獲得結束代碼 |
| atexit | pthread_cleanup_push | 注冊在控制流退出時候被調用的函數 |
| getpid | pthread_self | 獲得控制流的id |
| abort | pthread_cancel | 請求非正常退出 |
| ＃i nclude <pthread.h> int pthread_detach(pthread_t tid); |
| ＃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); |
| ＃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); |
| ＃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); |
| ＃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); |
| ＃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); |
| ＃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); |
| struct timespec { ?????? time_t tv_sec; ????? /* seconds */ ?????? long?? tv_nsec;????? /* nanoseconds */ }; |
| ＃i nclude <pthread.h> int pthread_cond_signal(pthread_cond_t *cond); int pthread_cond_broadcast(pthread_cond_t *cond); |
在傳統的Unix模型中，當一個進程需要由另一個實體執行某件事時，該進程派生（fork）一個子進程，讓子進程去進行處理。Unix下的大多數網絡服務器程序都是這么編寫的，即父進程接受連接，派生子進程，子進程處理與客戶的交互。
雖然這種模型很多年來使用得很好，但是fork時有一些問題：
1. fork是昂貴的。內存映像要從父進程拷貝到子進程，所有描述字要在子進程中復制等等。目前有的Unix實現使用一種叫做寫時拷貝（copy－on－write）的技術，可避免父進程數據空間向子進程的拷貝。盡管有這種優化技術，fork仍然是昂貴的。
2. fork子進程后，需要用進程間通信（IPC）在父子進程之間傳遞信息。Fork之前的信息容易傳遞，因為子進程從一開始就有父進程數據空間及所有描述字的拷貝。但是從子進程返回信息給父進程需要做更多的工作。
線程有助于解決這兩個問題。線程有時被稱為輕權進程（lightweight process），因為線程比進程“輕權”，一般來說，創建一個線程要比創建一個進程快10～100倍。
一個進程中的所有線程共享相同的全局內存，這使得線程很容易共享信息，但是這種簡易性也帶來了同步問題。
一個進程中的所有線程不僅共享全局變量，而且共享：進程指令、大多數數據、打開的文件（如描述字）、信號處理程序和信號處置、當前工作目錄、用戶ID和組ID。但是每個線程有自己的線程ID、寄存器集合（包括程序計數器和棧指針）、棧（用于存放局部變量和返回地址）、error、信號掩碼、優先級。在Linux中線程編程符合Posix.1標準，稱為Pthreads。所有的pthread函數都以pthread_開頭。以下先講述5個基本線程函數，在調用它們前均要包括pthread.h頭文件。然后再給出用它們編寫的一個TCP客戶/服務器程序例子。
第一個函數：
?
| int pthread_create (pthread_t ＊tid,const pthread_attr_t ＊attr,void ＊ (＊func)(void ＊),void ＊arg)； |
一個進程中的每個線程都由一個線程ID（thread ID）標識，其數據類型是pthread_t（常常是unsigned int）。如果新的線程創建成功，其ID將通過tid指針返回。
每個線程都有很多屬性：優先級、起始棧大小、是否應該是一個守護線程等等，當創建線程時，我們可通過初始化一個pthread_attr_t變量說明這些屬性以覆蓋缺省值。我們通常使用缺省值，在這種情況下，我們將attr參數說明為空指針。
最后，當創建一個線程時，我們要說明一個它將執行的函數。線程以調用該函數開始，然后或者顯式地終止（調用pthread_exit）或者隱式地終止（讓該函數返回）。函數的地址由func參數指定，該函數的調用參數是一個指針arg，如果我們需要多個調用參數，我們必須將它們打包成一個結構，然后將其地址當作唯一的參數傳遞給起始函數。
在func和arg的聲明中，func函數取一個通用指針（void ＊）參數，并返回一個通用指針（void ＊），這就使得我們可以傳遞一個指針（指向任何我們想要指向的東西）給線程，由線程返回一個指針（同樣指向任何我們想要指向的東西）。調用成功，返回0，出錯時返回正Exxx值。Pthread函數不設置errno。
第二個函數：
?
| int pthread_join(pthread_t tid,void ＊＊status); |
該函數等待一個線程終止。把線程和進程相比，pthread_creat類似于fork，而 pthread_join類似于waitpid。我們必須要等待線程的tid，很可惜，我們沒有辦法等待任意一個線程結束。如果status指針非空，線程的返回值（一個指向某個對象的指針）將存放在status指向的位置。
第三個函數：
?
| pthread_t pthread_self(void); |
線程都有一個ID以在給定的進程內標識自己。線程ID由pthread_creat返回，我們可以pthread_self取得自己的線程ID。
第四個函數：
?
| int pthread_detach(pthread_t tid); |
線程或者是可匯合的（joinable）或者是脫離的（detached）。當可匯合的線程終止時，其線程ID和退出狀態將保留，直到另外一個線程調用pthread_join。脫離的線程則像守護進程：當它終止時，所有的資源都釋放，我們不能等待它終止。如果一個線程需要知道另一個線程什么時候終止，最好保留第二個線程的可匯合性。Pthread_detach函數將指定的線程變為脫離的。該函數通常被想脫離自己的線程調用，如：pthread_detach?(pthread_self ( ));
?
?
第五個函數：?
| void pthread_exit(void ＊status); |
該函數終止線程。如果線程未脫離，其線程ID和退出狀態將一直保留到調用進程中的某個其他線程調用pthread_join函數。指針status不能指向局部于調用線程的對象，因為線程終止時這些對象也消失。有兩種其他方法可使線程終止：
1. 啟動線程的函數（pthread_creat的第3個參數）返回。既然該函數必須說明為返回一個void指針，該返回值便是線程的終止狀態。
2. 如果進程的main函數返回或者任何線程調用了exit，進程將終止，線程將隨之終止。
一.pthread_create()之前的屬性設置
1．線程屬性設置
我們用pthread_create函數創建一個線程，在這個線程中，我們使用默認參數，即將該函數的第二個參數設為NULL。的確，對大多數程序來說，使用默認屬性就夠了，但我們還是有必要來了解一下線程的有關屬性。
屬性結構為pthread_attr_t，它同樣在頭文件pthread.h中定義，屬性值不能直接設置，須使用相關函數進行操作，初始化的函數為pthread_attr_init，這個函數必須在pthread_create函數之前調用。屬性對象主要包括是否綁定、是否分離、
堆棧地址、堆棧大小、優先級。默認的屬性為非綁定、非分離、缺省的堆棧、與父進程同樣級別的優先級。
2．綁定
關于線程的綁定，牽涉到另外一個概念：輕進程（LWP：Light Weight Process）。輕進程可以理解為內核線程，它位于用戶層和系統層之間。系統對線程資源的分配、對線程的控制是通過輕進程來實現的，一個輕進程可以控制一個或多個線程。默認狀況下，啟動多少輕進程、哪些輕進程來控制哪些線程是由系統來控制的，這種狀況即稱為非綁定的。綁定狀況下，則顧名思義，即某個線程固定的"綁"在一個輕進程之上。被綁定的線程具有較高的響應速度，這是因為CPU時間片的調度是面向輕進程的，綁定的線程可以保證在需要的時候它總有一個輕進程可用。通過設置被綁定的輕進程的優先級和調度級可以使得綁定的線程滿足諸如實時反應之類的要求。
設置線程綁定狀態的函數為 pthread_attr_setscope，它有兩個參數，第一個是指向屬性結構的指針，第二個是綁定類型，它有兩個取值： PTHREAD_SCOPE_SYSTEM（綁定的）和PTHREAD_SCOPE_PROCESS（非綁定的）。下面的代碼即創建了一個綁定的線程。
＃i nclude <pthread.h>
pthread_attr_t attr;
pthread_t tid;
/*初始化屬性值，均設為默認值*/
pthread_attr_init(&attr);?
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
pthread_create(&tid, &attr, (void *) my_function, NULL);
3．線程分離狀態? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ???線程的分離狀態決定一個線程以什么樣的方式來終止自己。非分離的線程終止時，其線程ID和退出狀態將保留，直到另外一個線程調用 pthread_join.分離的線程在當它終止時，所有的資源將釋放，我們不能等待它終止。? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ???設置線程分離狀態的函數為 pthread_attr_setdetachstate（pthread_attr_t *attr, int detachstate）。第二個參數可選為PTHREAD_CREATE_DETACHED（分離線程）和 PTHREAD _CREATE_JOINABLE（非分離線程）。這里要注意的一點是，如果設置一個線程為分離線程，而這個線程運行又非常快，它很可能在 pthread_create函數返回之前就終止了，它終止以后就可能將線程號和系統資源移交給其他的線程使用，這樣調用pthread_create的線程就得到了錯誤的線程號。要避免這種情況可以采取一定的同步措施，最簡單的方法之一是可以在被創建的線程里調用 pthread_cond_timewait函數，讓這個線程等待一會兒，留出足夠的時間讓函數pthread_create返回。設置一段等待時間，是在多線程編程里常用的方法。
4．優先級? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ? 它存放在結構sched_param中。用函數pthread_attr_getschedparam和函數 pthread_attr_setschedparam進行存放，一般說來，我們總是先取優先級，對取得的值修改后再存放回去。下面即是一段簡單的例子。
＃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);?
/*設置優先級*/
pthread_attr_getschedparam(&attr, ¶m);??
param.sched_priority=newprio;
pthread_attr_setschedparam(&attr, ¶m);
pthread_create(&tid, &attr, (void *)myfunction, myarg);
二．線程數據處理? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?和進程相比，線程的最大優點之一是數據的共享性，各個進程共享父進程處沿襲的數據段，可以方便的獲得、修改數據。但這也給多線程編程帶來了許多問題。我們必須當心有多個不同的進程訪問相同的變量。許多函數是不可重入的，即同時不能運行一個函數的多個拷貝（除非使用不同的數據段）。在函數中聲明的靜態變量常常帶來問題，函數的返回值也會有問題。因為如果返回的是函數內部靜態聲明的空間的地址，則在一個線程調用該函數得到地址后使用該地址指向的數據時，別的線程可能調用此函數并修改了這一段數據。在進程中共享的變量必須用關鍵字volatile來定義，這是為了防止編譯器在優化時（如gcc中使用-OX參數）改變它們的使用方式。為了保護變量，我們必須使用信號量、互斥等方法來保證我們對變量的正確使用。
1．線程數據? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ? 在單線程的程序里，有兩種基本的數據：全局變量和局部變量。但在多線程程序里，還有第三種數據類型：線程數據（TSD: Thread-Specific Data）。它和全局變量很象，在線程內部，各個函數可以象使用全局變量一樣調用它，但它對線程外部的其它線程是不可見的。例如我們常見的變量 errno，它返回標準的出錯信息。它顯然不能是一個局部變量，幾乎每個函數都應該可以調用它；但它又不能是一個全局變量，否則在 A線程里輸出的很可能是B線程的出錯信息。要實現諸如此類的變量，我們就必須使用線程數據。我們為每個線程數據創建一個鍵，它和這個鍵相關聯，在各個線程里，都使用這個鍵來指代線程數據，但在不同的線程里，這個鍵代表的數據是不同的，在同一個線程里，它代表同樣的數據內容。
和線程數據相關的函數主要有4個：創建一個鍵；為一個鍵指定線程數據；從一個鍵讀取線程數據；刪除鍵。
創建鍵的函數原型為：
int pthread_key_create __P ((pthread_key_t *__key,void (*__destr_function) (void *)));? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ? 第一個參數為指向一個鍵值的指針，第二個參數指明了一個destructor函數，如果這個參數不為空，那么當每個線程結束時，系統將調用這個函數來釋放綁定在這個鍵上的內存塊。這個函數常和函數pthread_once ((pthread_once_t*once_control, void (*initroutine) (void)))一起使用，為了讓這個鍵只被創建一次。函數pthread_once聲明一個初始化函數，第一次調用pthread_once時它執行這個函數，以后的調用將被它忽略。
int pthread_key_delete(pthread_key_t *key);
該函數用于刪除一個由pthread_key_create 函數調用創建的鍵。調用成功返回值為0，否則返回錯誤代碼。
在下面的例子中，我們創建一個鍵，并將它和某個數據相關聯。我們要定義一個函數 createWindow，這個函數定義一個圖形窗口（數據類型為Fl_Window *，這是圖形界面開發工具FLTK中的數據類型）。由于各個線程都會調用這個函數，所以我們使用線程數據。
/* 聲明一個鍵*/
pthread_key_t myWinKey;
/* 函數 createWindow */
void createWindow ( void ) {
Fl_Window * win;
static pthread_once_t once= PTHREAD_ONCE_INIT;
/* 調用函數createMyKey，創建鍵*/
pthread_once ( & once, createMyKey) ;
/*win指向一個新建立的窗口*/
win=new Fl_Window( 0, 0, 100, 100, "MyWindow");
/* 對此窗口作一些可能的設置工作，如大小、位置、名稱等*/
setWindow(win);
/* 將窗口指針值綁定在鍵myWinKey上*/
pthread_setpecific ( myWinKey, win);
}
/* 函數 createMyKey，創建一個鍵，并指定了destructor */
void createMyKey ( void ) {
pthread_keycreate(&myWinKey, freeWinKey);
}
/* 函數 freeWinKey，釋放空間*/
void freeWinKey ( Fl_Window * win){
delete win;
}
這樣，在不同的線程中調用函數createMyWin，都可以得到在線程內部均可見的窗口變量，這個變量通過函數 pthread_getspecific得到。在上面的例子中，我們已經使用了函數pthread_setspecific來將線程數據和一個鍵綁定在一起。這兩個函數的原型如下：
int pthread_setspecific __P ((pthread_key_t __key,__const void *__pointer)); 該函數設置一個線程專有數據的值，賦給由pthread_key_create 創建的鍵，調用成功返回值為0，否則返回錯誤代碼。
void *pthread_getspecific __P ((pthread_key_t __key));? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ???該函數獲得綁定到指定鍵上的值。調用成功，返回給定參數key 所對應的數據。如果沒有數據連接到該鍵，則返回NULL。
這兩個函數的參數意義和使用方法是顯而易見的。要注意的是，用pthread_setspecific為一個鍵指定新的線程數據時，必須自己釋放原有的線程數據以回收空間。這個過程函數pthread_key_delete用來刪除一個鍵，這個鍵占用的內存將被釋放，但同樣要注意的是，它只釋放鍵占用的內存，并不釋放該鍵關聯的線程數據所占用的內存資源，而且它也不會觸發函數pthread_key_create中定義的destructor函數。線程數據的釋放必須在釋放鍵之前完成。
2．互斥鎖? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ?? ? 假設各個現成向同一個文件順序寫入數據，最后得到的結果是不可想象的。所以用互斥鎖來保證一段時間內只有一個線程在執行一段代碼。
使用int pthread_mutex_lock鎖住互斥鎖，使用int pthread_mutex_unlock解瑣。
如果我們試圖為一個已被其他線程鎖住的互斥鎖加鎖，程序便會阻塞直到該互斥對象解鎖。
如果在共享內存中分配一個互斥鎖，我們必須在運行時調用ptgread_mutex_init函數盡心初始化。
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);
}
}
函數 pthread_mutex_init用來生成一個互斥鎖。NULL參數表明使用默認屬性。如果需要聲明特定屬性的互斥鎖，須調用函數 pthread_mutexattr_init。函數pthread_mutexattr_setpshared和函數 pthread_mutexattr_settype用來設置互斥鎖屬性。前一個函數設置屬性pshared，它有兩個取值， PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用來不同進程中的線程同步，后者用于同步本進程的不同線程。在上面的例子中，我們使用的是默認屬性PTHREAD_PROCESS_ PRIVATE。后者用來設置互斥鎖類型，可選的類型有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、 PTHREAD_MUTEX_RECURSIVE和PTHREAD _MUTEX_DEFAULT。它們分別定義了不同的上所、解鎖機制，一般情況下，選用最后一個默認屬性。
需要注意的是在使用互斥鎖的過程中很有可能會出現死鎖：兩個線程試圖同時占用兩個資源，并按不同的次序鎖定相應的互斥鎖，例如兩個線程都需要鎖定互斥鎖1和互斥鎖2，a線程先鎖定互斥鎖1，b 線程先鎖定互斥鎖2，這時就出現了死鎖。此時我們可以使用函數 pthread_mutex_trylock，它是函數pthread_mutex_lock的非阻塞版本，當它發現死鎖不可避免時，它會返回相應的信息，程序員可以針對死鎖做出相應的處理。另外不同的互斥鎖類型對死鎖的處理不一樣，但最主要的還是要程序員自己在程序設計注意這一點。
3．條件變量
互斥鎖一個明顯的缺點是它只有兩種狀態：鎖定和非鎖定。而條件變量通過允許線程阻塞和等待另一個線程發送信號的方法彌補了互斥鎖的不足，它常和互斥鎖一起使用。使用時，條件變量被用來阻塞一個線程，當條件不滿足時，線程往往解開相應的互斥鎖并等待條件發生變化。一旦其它的某個線程改變了條件變量，它將通知相應的條件變量喚醒一個或多個正被此條件變量阻塞的線程。這些線程將重新鎖定互斥鎖并重新測試條件是否滿足。一般說來，條件變量被用來進行線承間的同步。
條件變量的結構為pthread_cond_t，函數pthread_cond_init（）被用來初始化一個條件變量。它的原型為：
int pthread_cond_init __P ((pthread_cond_t *__cond,__const pthread_condattr_t *__cond_attr));
? ?? ?? ??
其中cond是一個指向結構pthread_cond_t的指針，cond_attr是一個指向結構pthread_condattr_t的指針。結構 pthread_condattr_t是條件變量的屬性結構，和互斥鎖一樣我們可以用它來設置條件變量是進程內可用還是進程間可用，默認值是 PTHREAD_ PROCESS_PRIVATE，即此條件變量被同一進程內的各個線程使用。注意初始化條件變量只有未被使用時才能重新初始化或被釋放。
在pthread中，條件變量是一個pthread_cond_t類型的變量，條件變量使用下面兩個函數：
pthread_cond_wait 函數用于阻塞，線程可以被函數pthread_cond_signal和函數? ? pthread_cond_broadcast喚醒，但是要注意的是，條件變量只是起阻塞和喚醒線程的作用，具體的判斷條件還需用戶給出，例如一個變量是否為0等等，這一點我們從后面的例子中可以看到。線程被喚醒后，它將重新檢查判斷條件是否滿足，如果還不滿足，一般說來線程應該仍阻塞在這里，被等待被下一次喚醒。這個過程一般用while語句實現。
另一個用來阻塞線程的函數是pthread_cond_timedwait（）它比函數pthread_cond_wait（）多了一個時間參數，經歷abstime段時間后，即使條件變量不滿足，阻塞也被解除。
函數pthread_cond_signal（）用來釋放被阻塞在條件變量cond上的一個線程。
函數pthread_cond_broadcast（pthread_cond_t *cond）用來喚醒所有被阻塞在條件變量cond上的線程。這些線程被喚醒后將再次競爭相應的互斥鎖，所以必須小心使用這個函數。
下面是使用函數pthread_cond_wait（）和函數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函數在pthread_cond_wait處被阻塞，并打開互斥鎖count_lock。此時，當調用到函數 increment_count時，pthread_cond_signal（）函數改變條件變量，告知decrement_count（）停止阻塞。
=================================================================================
?
pthread_mutex_lock
?
函數名
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()函數鎖住由mutex指定的mutex?對象。如果mutex已經被鎖住，調用這個函數的線程阻塞直到mutex可用為止。這跟函數返回的時候參數mutex指定的mutex對象變成鎖住狀態，同時該函數的調用線程成為該mutex對象的擁有者。 如果mutex?對象的type是?PTHREAD_MUTEX_NORMAL，不進行deadlock detection(死鎖檢測)。企圖進行relock?這個mutex會導致deadlock.如果一個線程對未加鎖的或已經unlock的mutex對象進行unlock操作，結果是不未知的。 如果mutex類型是?PTHREAD_MUTEX_ERRORCHECK，那么將進行錯誤檢查。如果一個線程企圖對一個已經鎖住的mutex進行relock，將返回一個錯誤。如果一個線程對未加鎖的或已經unlock的mutex對象進行unlock操作，將返回一個錯誤。 如果mutex類型是?PTHREAD_MUTEX_RECURSIVE，mutex會有一個鎖住次數（lock count）的概念。當一個線程成功地第一次鎖住一個mutex的時候，鎖住次數（lock count）被設置為1，每一次一個線程unlock這個mutex的時候，鎖住次數（lock count）就減1。當鎖住次數（lock count）減少為0的時候，其他線程就能獲得該mutex鎖了。如果一個線程對未加鎖的或已經unlock的mutex對象進行unlock操作，將返回一個錯誤。 如果mutex類型是?PTHREAD_MUTEX_DEFAULT，企圖遞歸的獲取這個mutex的鎖的結果是不確定的。unlock一個不是被調用線程鎖住的mutex的結果也是不確定的。企圖unlock一個未被鎖住的mutex導致不確定的結果。 pthread_mutex_trylock()調用在參數mutex指定的mutex對象當前被鎖住的時候立即返回，除此之外，pthread_mutex_trylock()跟pthread_mutex_lock()功能完全一樣。 The?pthread_mutex_unlock()函數釋放有參數mutex指定的mutex對象的鎖。如果被釋放取決于該Mutex對象的類型屬性。如果有多個線程為了獲得該mutex鎖阻塞，調用pthread_mutex_unlock()將是該mutex可用，一定的調度策略將被用來決定哪個線程可以獲得該mutex鎖。（在mutex類型為PTHREAD_MUTEX_RECURSIVE?的情況下，只有當lock count?減為0并且調用線程在該mutex上已經沒有鎖的時候）（翻譯到這里，才覺得我的這個鎖概念是多么模糊） 如果一個線程在等待一個mutex鎖得時候收到了一個signal,那么在從signal handler返回的時候，該線程繼續等待該mutex鎖，就像這個線程沒有被中斷一樣。 返回值 成功，pthread_mutex_lock()?和?pthread_mutex_unlock()?返回0，否則返回一個錯誤的提示碼 pthread_mutex_trylock()?在成功獲得了一個mutex的鎖后返回0，否則返回一個錯誤提示碼錯誤
pthread_mutex_lock()?和?pthread_mutex_unlock()失敗的時候 [EINVAL] mutex在生成的時候，它的protocol屬性的值是?PTHREAD_PRIO_PROTECT，同時調用線程的優先級(priority)比該mutex的當前prority上限高 pthread_mutex_trylock()?函數在一下情況會失敗： [EBUSY]=================================================================================
?
pthread_join函數及linux線程
?
pthread_join使一個線程等待另一個線程結束。
代碼中如果沒有pthread_join主線程會很快結束從而使整個進程結束，從而使創建的線程沒有機會開始執行就結束了。加入pthread_join后，主線程會一直等待直到等待的線程結束自己才結束，使創建的線程有機會執行。
所有線程都有一個線程號，也就是Thread ID。其類型為pthread_t。通過調用pthread_self()函數可以獲得自身的線程號。
下面說一下如何創建一個線程。
通過創建線程，線程將會執行一個線程函數，該線程格式必須按照下面來聲明：
?????? void * Thread_Function(void *)
創建線程的函數如下：
?????? int pthread_create(pthread_t *restrict thread,
????????????? const pthread_attr_t *restrict attr,
????????????? void *(*start_routine)(void*), void *restrict arg);
下面說明一下各個參數的含義：
thread：所創建的線程號。
attr：所創建的線程屬性，這個將在后面詳細說明。
start_routine：即將運行的線程函數。
art：傳遞給線程函數的參數。
下面是一個簡單的創建線程例子：
| #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; } |
在編譯的時候需要注意，由于線程創建函數在libpthread.so庫中，所以在編譯命令中需要將該庫導入。命令如下：
gcc –o createthread –lpthread createthread.c
如果想傳遞參數給線程函數，可以通過其參數arg，其類型是void *。如果你需要傳遞多個參數的話，可以考慮將這些參數組成一個結構體來傳遞。另外，由于類型是void *，所以你的參數不可以被提前釋放掉。
下面一個問題和前面創建進程類似，不過帶來的問題回避進程要嚴重得多。如果你的主線程，也就是main函數執行的那個線程，在你其他縣城推出之前就已經退出，那么帶來的bug則不可估量。通過pthread_join函數會讓主線程阻塞，直到所有線程都已經退出。
int pthread_join(pthread_t thread, void **value_ptr);
thread：等待退出線程的線程號。
value_ptr：退出線程的返回值。
下面一個例子結合上面的內容：
| 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; } |
下面說一下前面提到的線程屬性。
在我們前面提到，可以通過pthread_join()函數來使主線程阻塞等待其他線程退出，這樣主線程可以清理其他線程的環境。但是還有一些線程，更喜歡自己來清理退出的狀態，他們也不愿意主線程調用pthread_join來等待他們。我們將這一類線程的屬性稱為detached。如果我們在調用pthread_create()函數的時候將屬性設置為NULL，則表明我們希望所創建的線程采用默認的屬性，也就是jionable。如果需要將屬性設置為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); } |
在線程設置為joinable后，可以調用pthread_detach()使之成為detached。但是相反的操作則不可以。還有，如果線程已經調用pthread_join()后，則再調用pthread_detach()則不會有任何效果。
線程可以通過自身執行結束來結束，也可以通過調用pthread_exit()來結束線程的執行。另外，線程甲可以被線程乙被動結束。這個通過調用pthread_cancel()來達到目的。
int pthread_cancel(pthread_t thread);
?????? 函數調用成功返回0。
當然，線程也不是被動的被別人結束。它可以通過設置自身的屬性來決定如何結束。
線程的被動結束分為兩種，一種是異步終結，另外一種是同步終結。異步終結就是當其他線程調用 pthread_cancel的時候，線程就立刻被結束。而同步終結則不會立刻終結，它會繼續運行，直到到達下一個結束點（cancellation point）。當一個線程被按照默認的創建方式創建，那么它的屬性是同步終結。
通過調用pthread_setcanceltype()來設置終結狀態。
int pthread_setcanceltype(int type, int *oldtype);
state：要設置的狀態，可以為PTHREAD_CANCEL_DEFERRED或者為PTHREAD_CANCEL_ASYNCHRONOUS。
那么前面提到的結束點又是如何設置了？最常用的創建終結點就是調用pthread_testcancel()的地方。該函數除了檢查同步終結時的狀態，其他什么也不做。
上面一個函數是用來設置終結狀態的。還可以通過下面的函數來設置終結類型，即該線程可不可以被終結：
int pthread_setcancelstate(int state, int *oldstate);
?????? state：終結狀態，可以為PTHREAD_CANCEL_DISABLE或者PTHREAD_CANCEL_ENABLE。具體什么含義大家可以通過單詞意思即可明白。
最后說一下線程的本質。其實在Linux中，新建的線程并不是在原先的進程中，而是系統通過一個系統調用clone()。該系統copy了一個和原先進程完全一樣的進程，并在這個進程中執行線程函數。不過這個copy過程和fork不一樣。 copy后的進程和原先的進程共享了所有的變量，運行環境。這樣，原先進程中的變量變動在copy后的進程中便能體現出來。
總結
以上是生活随笔為你收集整理的clone的fork与pthread_create创建线程有何不同pthread多线程编程的学习小结的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 校外分散实习（1）
- 下一篇： python3.5 安装PyCrypto