線程分類
線程按照其調度者可以分為用戶級線程和核心級線程兩種。
（1）用戶級線程
用戶級線程主要解決的是上下文切換的問題，它的調度算法和調度過程全部由用戶自行選擇決定，在運行時不需要特定的內核支持。在這里，操作系統(tǒng)往往會提供一個用戶空間的線程庫，該線程庫提供了線程的創(chuàng)建、調度、撤銷等功能，而內核仍然僅對進程進行管理。如果一個進程中的某一個線程調用了一個阻塞的系統(tǒng)調用，那么該進程包括該進程中的其他所有線程也同時被阻塞。這種用戶級線程的主要缺點是在一個進程中的多個線程的調度中無法發(fā)揮多處理器的優(yōu)勢。
（2）核心級線程
這種線程允許不同進程中的線程按照同一相對優(yōu)先調度方法進行調度，這樣就可以發(fā)揮多處理器的并發(fā)優(yōu)勢。
現(xiàn)在大多數(shù)系統(tǒng)都采用用戶級線程與核心級線程并存的方法。一個用戶級線程可以對應一個或幾個核心級線程，也就是“一對一”或“多對一”模型。這樣既可滿足多處理機系統(tǒng)的需要，也可以最大限度地減少調度開銷。
Linux的線程實現(xiàn)是在核外進行的，核內提供的是創(chuàng)建進程的接口do_fork()。內核提供了兩個系統(tǒng)調用clone()和fork()，最終都用不同的參數(shù)調用do_fork()核內API。當然，要想實現(xiàn)線程，沒有核心對多進程（其實是輕量級進程）共享數(shù)據(jù)段的支持是不行的，因此，do_fork()提供了很多參數(shù)，包括CLONE_VM（共享內存空間）、CLONE_FS（共享文件系統(tǒng)信息）、 CLONE_FILES（共享文件描述符表）、CLONE_SIGHAND（共享信號句柄表）和CLONE_PID（共享進程ID，僅對核內進程，即0號進程有效）。當使用fork系統(tǒng)調用時，內核調用do_fork()不使用任何共享屬性，進程擁有獨立的運行環(huán)境，而使用 pthread_create()來創(chuàng)建線程時，則最終設置了所有這些屬性來調用__clone()，而這些參數(shù)又全部傳給核內的do_fork()，從而創(chuàng)建的“進程”擁有共享的運行環(huán)境，只有棧是獨立的，由__clone()傳入。
Linux線程在核內是以輕量級進程的形式存在的，擁有獨立的進程表項，而所有的創(chuàng)建、同步、刪除等操作都在核外pthread庫中進行。pthread 庫使用一個管理線程（__pthread_manager()，每個進程獨立且唯一）來管理線程的創(chuàng)建和終止，為線程分配線程ID，發(fā)送線程相關的信號（比如Cancel），而主線程（pthread_create()）的調用者則通過管道將請求信息傳給管理線程。
主要函數(shù)說明
1．線程的創(chuàng)建和退出
pthread_create 線程創(chuàng)建函數(shù)
int pthread_create (pthread_t * thread_id,__const pthread_attr_t * __attr,void *(*__start_routine) (void *),void *__restrict __arg);
線程創(chuàng)建函數(shù)第一個參數(shù)為指向線程標識符的指針，第二個參數(shù)用來設置線程屬性，第三個參數(shù)是線程運行函數(shù)的起始地址，最后一個參數(shù)是運行函數(shù)的參數(shù)。這里，我們的函數(shù)thread 不需要參數(shù)，所以最后一個參數(shù)設為空指針。第二個參數(shù)我們也設為空指針，這樣將生成默認屬性的線程。當創(chuàng)建線程成功時，函數(shù)返回0，若不為0 則說明創(chuàng)建線程失敗，常見的錯誤返回代碼為EAGAIN 和EINVAL。前者表示系統(tǒng)限制創(chuàng)建新的線程，例如線程數(shù)目過多了；后者表示第二個參數(shù)代表的線程屬性值非法。創(chuàng)建線程成功后，新創(chuàng)建的線程則運行參數(shù)三和參數(shù)四確定的函數(shù)，原來的線程則繼續(xù)運行下一行代碼。
pthread_join 函數(shù)，來等待一個線程的結束。
函數(shù)原型為：int pthread_join (pthread_t __th, void **__thread_return)
第一個參數(shù)為被等待的線程標識符，第二個參數(shù)為一個用戶定義的指針，它可以用來存儲被等待線程的返回值。這個函數(shù)是一個線程阻塞的函數(shù)，調用它的函數(shù)將一直等待到被等待的線程結束為止，當函數(shù)返回時，被等待線程的資源被收回。線程只能被一個線程等待終止,并且應處于joinable狀態(tài)(非detached)。
pthread_exit 函數(shù)
一個線程的結束有兩種途徑，一種是線程運行的函數(shù)結束了，調用它的線程也就結束了；
另一種方式是通過函數(shù)pthread_exit 來實現(xiàn)。它的函數(shù)原型為：void pthread_exit (void *__retval)唯一的參數(shù)是函數(shù)的返回代碼，只要pthread_join 中的第二個參數(shù)thread_return 不是NULL，這個值將被傳遞給thread_return。最后要說明的是，一個線程不能被多個線程等待，否則第一個接收到信號的線程成功返回，其余調用pthread_join 的線程則返回錯誤代碼ESRCH。
2．線程屬性
pthread_create函數(shù)的第二個參數(shù)線程的屬性。將該值設為NULL，也就是采用默認屬性，線程的多項屬性都是可以更改的。這些屬性主要包括綁定屬性、分離屬性、堆棧地址、堆棧大小、優(yōu)先級。其中系統(tǒng)默認的屬性為非綁定、非分離、缺省1M 的堆棧、與父進程同樣級別的優(yōu)先級。下面首先對綁定屬性和分離屬性的基本概念進行講解。
綁定屬性：Linux中采用“一對一”的線程機制，也就是一個用戶線程對應一個內核線程。綁定屬性就是指一個用戶線程固定地分配給一個內核線程，因為CPU時間片的調度是面向內核線程 （也就是輕量級進程）的，因此具有綁定屬性的線程可以保證在需要的時候總有一個內核線程與之對應。而與之相對的非綁定屬性就是指用戶線程和內核線程的關系不是始終固定的，而是由系統(tǒng)來控制分配的。
分離屬性：分離屬性是用來決定一個線程以什么樣的方式來終止自己。在非分離情況下，當一個線程結束時，它所占用的系統(tǒng)資源并沒有被釋放，也就是沒有真正的終止。只有當pthread_join()函數(shù)返回時，創(chuàng)建的線程才能釋放自己占用的系統(tǒng)資源。而在分離屬性情況下，一個線程結束時立即釋放它所占有的系統(tǒng)資源。
這里要注意的一點是，如果設置一個線程的分離屬性，而這個線程運行又非?？欤敲此芸赡茉趐thread_create 函數(shù)返回之前就終止了，它終止以后就可能將線程號和系統(tǒng)資源移交給其他的線程使用，這時調用pthread_create 的線程就得到了錯誤的線程號。
設置綁定屬性：
int pthread_attr_init(pthread_attr_t *attr)
int pthread_attr_setscope(pthread_attr_t *attr, int scope)
int pthread_attr_getscope(pthread_attr_t *tattr, int *scope)
scope：PTHREAD_SCOPE_SYSTEM：綁定，此線程與系統(tǒng)中所有的線程競爭 PTHREAD_SCOPE_PROCESS：非綁定，此線程與進程中的其他線程競爭
設置分離屬性：
int pthread_attr_setdetachstate(pthread_attr_t *attr, int detachstate)
int pthread_attr_getdetachstate(const pthread_attr_t *tattr,int *detachstate)
detachstate PTHREAD_CREATE_DETACHED：分離 PTHREAD _CREATE_JOINABLE：非分離
設置調度策略：
int pthread_attr_setschedpolicy(pthread_attr_t * tattr, int policy)
int pthread_attr_getschedpolicy(pthread_attr_t * tattr, int *policy)
policy SCHED_FIFO：先入先出 SCHED_RR：循環(huán) SCHED_OTHER：實現(xiàn)定義的方法
設置優(yōu)先級：
int pthread_attr_setschedparam (pthread_attr_t *attr, struct sched_param *param)
int pthread_attr_getschedparam (pthread_attr_t *attr, struct sched_param *param)
3．線程訪問控制
1）互斥鎖（mutex）
通過鎖機制實現(xiàn)線程間的同步。同一時刻只允許一個線程執(zhí)行一個關鍵部分的代碼。
1 int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutex_attr_t *mutexattr);
2 int pthread_mutex_lock(pthread_mutex_t *mutex);
3 int pthread_mutex_unlock(pthread_mutex_t *mutex);
4 int pthread_mutex_destroy(pthread_mutex_t *mutex);
(1)先初始化鎖init()或靜態(tài)賦值pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIER
(2)加鎖,lock,trylock,lock阻塞等待鎖,trylock立即返回EBUSY
(3)解鎖,unlock需滿足是加鎖狀態(tài),且由加鎖線程解鎖
(4)清除鎖,destroy(此時鎖必需unlock,否則返回EBUSY)
mutex 分為遞歸(recursive) 和非遞歸(non-recursive)兩種，這是POSIX 的叫法，另外的名字是可重入(Reentrant) 與非可重入。這兩種mutex 作為線程間(inter-thread) 的同步工具時沒有區(qū)別，它們的惟一區(qū)別在于：同一個線程可以重復對recursive mutex 加鎖，但是不能重復對non-recursive mutex 加鎖。
首選非遞歸mutex，絕對不是為了性能，而是為了體現(xiàn)設計意圖。non-recursive 和recursive 的性能差別其實不大，因為少用一個計數(shù)器，前者略快一點點而已。在同一個線程里多次對non-recursive mutex 加鎖會立刻導致死鎖，我認為這是它的優(yōu)點，能幫助我們思考代碼對鎖的期求，并且及早（在編碼階段）發(fā)現(xiàn)問題。毫無疑問recursive mutex 使用起來要方便一些，因為不用考慮一個線程會自己把自己給鎖死了，我猜這也是Java 和Windows 默認提供recursive mutex 的原因。（Java 語言自帶的intrinsic lock 是可重入的，它的concurrent 庫里提供ReentrantLock，Windows的CRITICAL_SECTION 也是可重入的。似乎它們都不提供輕量級的non-recursive mutex。）
2）條件變量（cond）
利用線程間共享的全局變量進行同步的一種機制。
1 int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);
2 int pthread_cond_wait(pthread_cond_t *cond,pthread_mutex_t *mutex);
3 int pthread_cond_timedwait(pthread_cond_t *cond,pthread_mutex_t *mutex,const timespec *abstime);
4 int pthread_cond_destroy(pthread_cond_t *cond);
5 int pthread_cond_signal(pthread_cond_t *cond);
6 int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有線程的阻塞
(1)初始化. init()或者pthread_cond_t cond=PTHREAD_COND_INITIALIER;屬性置為NULL
(2)等待條件成立. pthread_cond_wait,pthread_cond_timedwait.
wait()釋放鎖,并阻塞等待條件變量為真
timedwait()設置等待時間,仍未signal,返回ETIMEOUT(加鎖保證只有一個線程wait)
(3)激活條件變量:pthread_cond_signal,pthread_cond_broadcast(激活所有等待線程)
(4)清除條件變量:destroy; 無線程等待,否則返回EBUSY
復制代碼 代碼如下:
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);
這兩個函數(shù)一定要在mutex的鎖定區(qū)域內使用。
調用 pthread_cond_signal() 釋放被條件阻塞的線程時，如果沒有任何線程基于條件變量阻塞，則調用pthread_cond_signal()不起作用。而對于 Windows，當調用 SetEvent 觸發(fā) Auto-reset 的 Event 條件時，如果沒有被條件阻塞的線程，那么此函數(shù)仍然起作用，條件變量會處在觸發(fā)狀態(tài)。
Linux下生產(chǎn)者消費者問題（使用互斥鎖和條件變量）:
復制代碼 代碼如下:
#include stdio.h>
#include stdlib.h>
#include time.h>
#include "pthread.h"
#define BUFFER_SIZE 16
struct prodcons
{
int buffer[BUFFER_SIZE];
pthread_mutex_t lock; //mutex ensuring exclusive access to buffer
int readpos,writepos; //position for reading and writing
pthread_cond_t notempty; //signal when buffer is not empty
pthread_cond_t notfull; //signal when buffer is not full
};
//initialize a buffer
void init(struct prodcons* b)
{
pthread_mutex_init(b->lock,NULL);
pthread_cond_init(b->notempty,NULL);
pthread_cond_init(b->notfull,NULL);
b->readpos = 0;
b->writepos = 0;
}
//store an integer in the buffer
void put(struct prodcons* b, int data)
{
pthread_mutex_lock(b->lock);
//wait until buffer is not full
while((b->writepos+1)%BUFFER_SIZE == b->readpos)
{
printf("wait for not full\n");
pthread_cond_wait(b->notfull,b->lock);
}
b->buffer[b->writepos] = data;
b->writepos++;
b->writepos %= BUFFER_SIZE;
pthread_cond_signal(b->notempty); //signal buffer is not empty
pthread_mutex_unlock(b->lock);
}
//read and remove an integer from the buffer
int get(struct prodcons* b)
{
int data;
pthread_mutex_lock(b->lock);
//wait until buffer is not empty
while(b->writepos == b->readpos)
{
printf("wait for not empty\n");
pthread_cond_wait(b->notempty,b->lock);
}
data=b->buffer[b->readpos];
b->readpos++;
b->readpos %= BUFFER_SIZE;
pthread_cond_signal(b->notfull); //signal buffer is not full
pthread_mutex_unlock(b->lock);
return data;
}
#define OVER -1
struct prodcons buffer;
void * producer(void * data)
{
int n;
for(n=0; n50; ++n)
{
printf("put-->%d\n",n);
put(buffer,n);
}
put(buffer,OVER);
printf("producer stopped\n");
return NULL;
}
void * consumer(void * data)
{
int n;
while(1)
{
int d = get(buffer);
if(d == OVER) break;
printf("get-->%d\n",d);
}
printf("consumer stopped\n");
return NULL;
}
int main()
{
pthread_t tha,thb;
void * retval;
init(buffer);
pthread_creare(tha,NULL,producer,0);
pthread_creare(thb,NULL,consumer,0);
pthread_join(tha,retval);
pthread_join(thb,retval);
return 0;
}
3）信號量
如同進程一樣，線程也可以通過信號量來實現(xiàn)通信，雖然是輕量級的。
信號量函數(shù)的名字都以"sem_"打頭。線程使用的基本信號量函數(shù)有四個。
復制代碼 代碼如下:
#include semaphore.h>
int sem_init(sem_t *sem , int pshared, unsigned int value);
這是對由sem指定的信號量進行初始化，設置好它的共享選項（linux只支持為0，即表示它是當前進程的局部信號量），然后給它一個初始值VALUE。
兩個原子操作函數(shù)：這兩個函數(shù)都要用一個由sem_init調用初始化的信號量對象的指針做參數(shù)。
復制代碼 代碼如下:
int sem_wait(sem_t *sem); //給信號量減1，對一個值為0的信號量調用sem_wait，這個函數(shù)將會等待直到有其它線程使它不再是0為止。
int sem_post(sem_t *sem); //給信號量的值加1
int sem_destroy(sem_t *sem);
這個函數(shù)的作用是再我們用完信號量后都它進行清理。歸還自己占有的一切資源。
用信號量實現(xiàn)生產(chǎn)者消費者：
這里使用4個信號量，其中兩個信號量occupied和empty分別用于解決生產(chǎn)者和消費者線程之間的同步問題，pmut用于多個生產(chǎn)者之間互斥問題，cmut是用于多個消費者之間互斥問題。其中empty初始化為N（有界緩區(qū)的空間元數(shù)），occupied初始化為0，pmut和cmut初始化為1。
參考代碼：
復制代碼 代碼如下:
#define BSIZE 64
typedef struct
{
char buf[BSIZE];
sem_t occupied;
sem_t empty;
int nextin;
int nextout;
sem_t pmut;
sem_t cmut;
}buffer_t;
buffer_t buffer;
void init(buffer_t * b)
{
sem_init(b->occupied, 0, 0);
sem_init(b->empty,0, BSIZE);
sem_init(b->pmut, 0, 1);
sem_init(b->cmut, 0, 1);
b->nextin = b->nextout = 0;
}
void producer(buffer_t *b, char item)
{
sem_wait(b->empty);
sem_wait(b->pmut);
b->buf[b->nextin] = item;
b->nextin++;
b->nextin %= BSIZE;
sem_post(b->pmut);
sem_post(b->occupied);
}
char consumer(buffer_t *b)
{
char item;
sem_wait(b->occupied);
sem_wait(b->cmut);
item = b->buf[b->nextout];
b->nextout++;
b->nextout %= BSIZE;
sem_post(b->cmut);
sem_post(b->empty);
return item;
}
您可能感興趣的文章:- golang 監(jiān)聽服務的信號,實現(xiàn)平滑啟動,linux信號說明詳解
- Linux進程間通信--使用信號
- 詳解Linux進程間通信——使用信號量
- 詳解Linux多線程使用信號量同步
- Linux下的信號詳解及捕捉信號
- linux下基于C語言的信號編程實例
- Linux線程同步之信號C語言實例
- Linux下semop等待信號時出現(xiàn)Interrupted System Call錯誤(EINTR)解決方法
- 淺談Linux信號機制
