線程

　　線程是計(jì)算機(jī)中獨(dú)立運(yùn)行的最小單位，運(yùn)行時(shí)占用很少的系統(tǒng)資源?？梢园丫€程看成是操作系統(tǒng)分配CPU時(shí)間的基本單元。一個(gè)進(jìn)程可以擁有一個(gè)至多個(gè)線程。它線程在進(jìn)程內(nèi)部共享地址空間、打開的文件描述符等資源。同時(shí)線程也有其私有的數(shù)據(jù)信息，包括：線程號、寄存器（程序計(jì)數(shù)器和堆棧指針）、堆棧、信號掩碼、優(yōu)先級、線程私有存儲(chǔ)空間。

　　為什么有了進(jìn)程的概念后，還要再引入線程呢？使用多線程到底有哪些好處？什么的系統(tǒng)應(yīng)該選用多線程？

　　使用多線程的理由之一是和進(jìn)程相比，它是一種非?！肮?jié)儉”的多任務(wù)操作方式。我們知道，在Linux系統(tǒng)下，啟動(dòng)一個(gè)新的進(jìn)程必須分配給它獨(dú)立的地址空間，建立眾多的數(shù)據(jù)表來維護(hù)它的代碼段、堆棧段和數(shù)據(jù)段，這是一種“昂貴”的多任務(wù)工作方式。而運(yùn)行于一個(gè)進(jìn)程中的多個(gè)線程，它們彼此之間使用相同的地址空間，共享大部分?jǐn)?shù)據(jù)，啟動(dòng)一個(gè)線程所花費(fèi)的空間遠(yuǎn)遠(yuǎn)小于啟動(dòng)一個(gè)進(jìn)程所花費(fèi)的空間，而且，線程間彼此切換所需的時(shí)間也遠(yuǎn)遠(yuǎn)小于進(jìn)程間切換所需要的時(shí)間。據(jù)統(tǒng)計(jì)，總的說來，一個(gè)進(jìn)程的開銷大約是一個(gè)線程開銷的30倍左右，當(dāng)然，在具體的系統(tǒng)上，這個(gè)數(shù)據(jù)可能會(huì)有較大的區(qū)別。

　　使用多線程的理由之二是線程間方便的通信機(jī)制。對不同進(jìn)程來說，它們具有獨(dú)立的數(shù)據(jù)空間，要進(jìn)行數(shù)據(jù)的傳遞只能通過通信的方式進(jìn)行，這種方式不僅費(fèi)時(shí)，而且很不方便。線程則不然，由于同一進(jìn)程下的線程之間共享數(shù)據(jù)空間，所以一個(gè)線程的數(shù)據(jù)可以直接為其它線程所用，這不僅快捷，而且方便。當(dāng)然，數(shù)據(jù)的共享也帶來其他一些問題，有的變量不能同時(shí)被兩個(gè)線程所修改，有的子程序中聲明為static的數(shù)據(jù)更有可能給多線程程序帶來災(zāi)難性的打擊，這些正是編寫多線程程序時(shí)最需要注意的地方。

　　除了以上所說的優(yōu)點(diǎn)外，不和進(jìn)程比較，多線程程序作為一種多任務(wù)、并發(fā)的工作方式，當(dāng)然有以下的優(yōu)點(diǎn)：

　　1）提高應(yīng)用程序響應(yīng)。這對圖形界面的程序尤其有意義，當(dāng)一個(gè)操作耗時(shí)很長時(shí)，整個(gè)系統(tǒng)都會(huì)等待這個(gè)操作，此時(shí)程序不會(huì)響應(yīng)鍵盤、鼠標(biāo)、菜單的操作，而使用多線程技術(shù)，將耗時(shí)長的操作（time consuming）置于一個(gè)新的線程，可以避免這種尷尬的情況。

　　2）使多CPU系統(tǒng)更加有效。操作系統(tǒng)會(huì)保證當(dāng)線程數(shù)不大于CPU數(shù)目時(shí)，不同的線程運(yùn)行于不同的CPU上。

　　3）改善程序結(jié)構(gòu)。一個(gè)既長又復(fù)雜的進(jìn)程可以考慮分為多個(gè)線程，成為幾個(gè)獨(dú)立或半獨(dú)立的運(yùn)行部分，這樣的程序會(huì)利于理解和修改。

　　線程分類

　　線程按照其調(diào)度者可以分為用戶級線程和核心級線程兩種。

　?。?）用戶級線程

　　用戶級線程主要解決的是上下文切換的問題，它的調(diào)度算法和調(diào)度過程全部由用戶自行選擇決定，在運(yùn)行時(shí)不需要特定的內(nèi)核支持。在這里，操作系統(tǒng)往往會(huì)提供一個(gè)用戶空間的線程庫，該線程庫提供了線程的創(chuàng)建、調(diào)度、撤銷等功能，而內(nèi)核仍然僅對進(jìn)程進(jìn)行管理。如果一個(gè)進(jìn)程中的某一個(gè)線程調(diào)用了一個(gè)阻塞的系統(tǒng)調(diào)用，那么該進(jìn)程包括該進(jìn)程中的其他所有線程也同時(shí)被阻塞。這種用戶級線程的主要缺點(diǎn)是在一個(gè)進(jìn)程中的多個(gè)線程的調(diào)度中無法發(fā)揮多處理器的優(yōu)勢。

　?。?）核心級線程

　　這種線程允許不同進(jìn)程中的線程按照同一相對優(yōu)先調(diào)度方法進(jìn)行調(diào)度，這樣就可以發(fā)揮多處理器的并發(fā)優(yōu)勢。

　　現(xiàn)在大多數(shù)系統(tǒng)都采用用戶級線程與核心級線程并存的方法。一個(gè)用戶級線程可以對應(yīng)一個(gè)或幾個(gè)核心級線程，也就是“一對一”或“多對一”模型。這樣既可滿足多處理機(jī)系統(tǒng)的需要，也可以最大限度地減少調(diào)度開銷。

　　線程創(chuàng)建的Linux實(shí)現(xiàn)

　　我們知道，Linux的線程實(shí)現(xiàn)是在核外進(jìn)行的，核內(nèi)提供的是創(chuàng)建進(jìn)程的接口do_fork()。內(nèi)核提供了兩個(gè)系統(tǒng)調(diào)用clone()和fork()，最終都用不同的參數(shù)調(diào)用do_fork()核內(nèi)API。當(dāng)然，要想實(shí)現(xiàn)線程，沒有核心對多進(jìn)程（其實(shí)是輕量級進(jìn)程）共享數(shù)據(jù)段的支持是不行的，因此，do_fork()提供了很多參數(shù)，包括CLONE_VM（共享內(nèi)存空間）、CLONE_FS（共享文件系統(tǒng)信息）、 CLONE_FILES（共享文件描述符表）、CLONE_SIGHAND（共享信號句柄表）和CLONE_PID（共享進(jìn)程ID，僅對核內(nèi)進(jìn)程，即0號進(jìn)程有效）。當(dāng)使用fork系統(tǒng)調(diào)用時(shí)，內(nèi)核調(diào)用do_fork()不使用任何共享屬性，進(jìn)程擁有獨(dú)立的運(yùn)行環(huán)境，而使用 pthread_create()來創(chuàng)建線程時(shí)，則最終設(shè)置了所有這些屬性來調(diào)用__clone()，而這些參數(shù)又全部傳給核內(nèi)的do_fork()，從而創(chuàng)建的“進(jìn)程”擁有共享的運(yùn)行環(huán)境，只有棧是獨(dú)立的，由__clone()傳入。

　　Linux線程在核內(nèi)是以輕量級進(jìn)程的形式存在的，擁有獨(dú)立的進(jìn)程表項(xiàng)，而所有的創(chuàng)建、同步、刪除等操作都在核外pthread庫中進(jìn)行。pthread 庫使用一個(gè)管理線程（__pthread_manager()，每個(gè)進(jìn)程獨(dú)立且唯一）來管理線程的創(chuàng)建和終止，為線程分配線程ID，發(fā)送線程相關(guān)的信號（比如Cancel），而主線程（pthread_create()）的調(diào)用者則通過管道將請求信息傳給管理線程。

　　多線程編程

　　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ù)第一個(gè)參數(shù)為指向線程標(biāo)識符的指針，第二個(gè)參數(shù)用來設(shè)置線程屬性，第三個(gè)參數(shù)是線程運(yùn)行函數(shù)的起始地址，最后一個(gè)參數(shù)是運(yùn)行函數(shù)的參數(shù)。這里，我們的函數(shù)thread 不需要參數(shù)，所以最后一個(gè)參數(shù)設(shè)為空指針。第二個(gè)參數(shù)我們也設(shè)為空指針，這樣將生成默認(rèn)屬性的線程。當(dāng)創(chuàng)建線程成功時(shí)，函數(shù)返回0，若不為0 則說明創(chuàng)建線程失敗，常見的錯(cuò)誤返回代碼為EAGAIN 和EINVAL。前者表示系統(tǒng)限制創(chuàng)建新的線程，例如線程數(shù)目過多了；后者表示第二個(gè)參數(shù)代表的線程屬性值非法。創(chuàng)建線程成功后，新創(chuàng)建的線程則運(yùn)行參數(shù)三和參數(shù)四確定的函數(shù)，原來的線程則繼續(xù)運(yùn)行下一行代碼。

　　pthread_join 函數(shù)，來等待一個(gè)線程的結(jié)束。

　　函數(shù)原型為：int pthread_join (pthread_t __th, void **__thread_return)

　　第一個(gè)參數(shù)為被等待的線程標(biāo)識符，第二個(gè)參數(shù)為一個(gè)用戶定義的指針，它可以用來存儲(chǔ)被等待線程的返回值。這個(gè)函數(shù)是一個(gè)線程阻塞的函數(shù)，調(diào)用它的函數(shù)將一直等待到被等待的線程結(jié)束為止，當(dāng)函數(shù)返回時(shí)，被等待線程的資源被收回。線程只能被一個(gè)線程等待終止,并且應(yīng)處于joinable狀態(tài)(非detached)。

　　pthread_exit 函數(shù)

　　一個(gè)線程的結(jié)束有兩種途徑，一種是線程運(yùn)行的函數(shù)結(jié)束了，調(diào)用它的線程也就結(jié)束了；

　　另一種方式是通過函數(shù)pthread_exit 來實(shí)現(xiàn)。它的函數(shù)原型為：void pthread_exit (void *__retval)唯一的參數(shù)是函數(shù)的返回代碼，只要pthread_join 中的第二個(gè)參數(shù)thread_return 不是NULL，這個(gè)值將被傳遞給thread_return。最后要說明的是，一個(gè)線程不能被多個(gè)線程等待，否則第一個(gè)接收到信號的線程成功返回，其余調(diào)用pthread_join 的線程則返回錯(cuò)誤代碼ESRCH。

　　2、線程屬性

　　pthread_create函數(shù)的第二個(gè)參數(shù)線程的屬性。將該值設(shè)為NULL，也就是采用默認(rèn)屬性，線程的多項(xiàng)屬性都是可以更改的。這些屬性主要包括綁定屬性、分離屬性、堆棧地址、堆棧大小、優(yōu)先級。其中系統(tǒng)默認(rèn)的屬性為非綁定、非分離、缺省1M 的堆棧、與父進(jìn)程同樣級別的優(yōu)先級。下面首先對綁定屬性和分離屬性的基本概念進(jìn)行講解。

　　綁定屬性：Linux中采用“一對一”的線程機(jī)制，也就是一個(gè)用戶線程對應(yīng)一個(gè)內(nèi)核線程。綁定屬性就是指一個(gè)用戶線程固定地分配給一個(gè)內(nèi)核線程，因?yàn)镃PU時(shí)間片的調(diào)度是面向內(nèi)核線程 （也就是輕量級進(jìn)程）的，因此具有綁定屬性的線程可以保證在需要的時(shí)候總有一個(gè)內(nèi)核線程與之對應(yīng)。而與之相對的非綁定屬性就是指用戶線程和內(nèi)核線程的關(guān)系不是始終固定的，而是由系統(tǒng)來控制分配的。

　　分離屬性：分離屬性是用來決定一個(gè)線程以什么樣的方式來終止自己。在非分離情況下，當(dāng)一個(gè)線程結(jié)束時(shí)，它所占用的系統(tǒng)資源并沒有被釋放，也就是沒有真正的終止。只有當(dāng)pthread_join()函數(shù)返回時(shí)，創(chuàng)建的線程才能釋放自己占用的系統(tǒng)資源。而在分離屬性情況下，一個(gè)線程結(jié)束時(shí)立即釋放它所占有的系統(tǒng)資源。

　　這里要注意的一點(diǎn)是，如果設(shè)置一個(gè)線程的分離屬性，而這個(gè)線程運(yùn)行又非?？欤敲此芸赡茉趐thread_create 函數(shù)返回之前就終止了，它終止以后就可能將線程號和系統(tǒng)資源移交給其他的線程使用，這時(shí)調(diào)用pthread_create 的線程就得到了錯(cuò)誤的線程號。

　　設(shè)置綁定屬性：

　　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：非綁定，此線程與進(jìn)程中的其他線程競爭

　　設(shè)置分離屬性：

　　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：非分離

　　設(shè)置調(diào)度策略：

　　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：實(shí)現(xiàn)定義的方法

　　設(shè)置優(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）

　　通過鎖機(jī)制實(shí)現(xiàn)線程間的同步。同一時(shí)刻只允許一個(gè)線程執(zhí)行一個(gè)關(guān)鍵部分的代碼。

int pthread_mutex_init(pthread_mutex_t *mutex,const pthread_mutex_attr_t *mutexattr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_destroy(pthread_mutex_t *mutex);

　?。?）先初始化鎖init（）或靜態(tài)賦值pthread_mutex_t mutex=PTHREAD_MUTEX_INITIALIER

　　（2）加鎖，lock，trylock，lock阻塞等待鎖，trylock立即返回EBUSY

　?。?）解鎖，unlock需滿足是加鎖狀態(tài)，且由加鎖線程解鎖

　?。?）清除鎖，destroy（此時(shí)鎖必需unlock，否則返回EBUSY）

　　mutex 分為遞歸（recursive） 和非遞歸（non-recursive）兩種，這是POSIX 的叫法，另外的名字是可重入（Reentrant） 與非可重入。這兩種mutex 作為線程間（inter-thread） 的同步工具時(shí)沒有區(qū)別，它們的惟一區(qū)別在于：同一個(gè)線程可以重復(fù)對recursive mutex 加鎖，但是不能重復(fù)對non-recursive mutex 加鎖。

　　首選非遞歸mutex，絕對不是為了性能，而是為了體現(xiàn)設(shè)計(jì)意圖。non-recursive 和recursive 的性能差別其實(shí)不大，因?yàn)樯儆靡粋€(gè)計(jì)數(shù)器，前者略快一點(diǎn)點(diǎn)而已。在同一個(gè)線程里多次對non-recursive mutex 加鎖會(huì)立刻導(dǎo)致死鎖，我認(rèn)為這是它的優(yōu)點(diǎn)，能幫助我們思考代碼對鎖的期求，并且及早（在編碼階段）發(fā)現(xiàn)問題。毫無疑問recursive mutex 使用起來要方便一些，因?yàn)椴挥每紤]一個(gè)線程會(huì)自己把自己給鎖死了，我猜這也是Java 和Windows 默認(rèn)提供recursive mutex 的原因。（Java 語言自帶的intrinsic lock 是可重入的，它的concurrent 庫里提供ReentrantLock，Windows的CRITICAL_SECTION 也是可重入的。似乎它們都不提供輕量級的non-recursive mutex。）

　　2）條件變量（cond）

　　利用線程間共享的全局變量進(jìn)行同步的一種機(jī)制。

int pthread_cond_init(pthread_cond_t *cond,pthread_condattr_t *cond_attr);   
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 timespec *abstime);
int pthread_cond_destroy(pthread_cond_t *cond); 
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond); //解除所有線程的阻塞

　?。?）初始化. init()或者pthread_cond_t cond=PTHREAD_COND_INITIALIER；屬性置為NULL

　?。?）等待條件成立. pthread_cond_wait，pthread_cond_timedwait.

　　wait()釋放鎖，并阻塞等待條件變量為真

　　timedwait()設(shè)置等待時(shí)間，仍未signal，返回ETIMEOUT(加鎖保證只有一個(gè)線程wait)

　?。?）激活條件變量：pthread_cond_signal，pthread_cond_broadcast（激活所有等待線程）

　?。?）清除條件變量：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)；

　　一定要在mutex的鎖定區(qū)域內(nèi)使用。

　　調(diào)用 pthread_cond_signal() 釋放被條件阻塞的線程時(shí)，如果沒有任何線程基于條件變量阻塞，則調(diào)用pthread_cond_signal()不起作用。而對于 Windows，當(dāng)調(diào)用 SetEvent 觸發(fā) Auto-reset 的 Event 條件時(shí)，如果沒有被條件阻塞的線程，那么此函數(shù)仍然起作用，條件變量會(huì)處于觸發(fā)狀態(tài)。

　　使用條件變量實(shí)現(xiàn)“生產(chǎn)者消費(fèi)者問題”：

　　#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++;
   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++;
   if(b->readpos>=BUFFER_SIZE) b->readpos=0;
   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;n<1000;++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("%d-->get\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;
}

　　PS：如果遇到如下問題：加個(gè)編譯條件'-pthread'

　　prodcons.c:(.text+0x2ab): undefined reference to `pthread_create'
　　prodcons.c:(.text+0x2bd): undefined reference to `pthread_join'

　　3）信號量

　　如同進(jìn)程一樣，線程也可以通過信號量來實(shí)現(xiàn)通信，雖然是輕量級的。

　　信號量函數(shù)的名字都以"sem_"打頭。線程使用的基本信號量函數(shù)有四個(gè)。

　　#include <semaphore.h>

　　int sem_init(sem_t *sem , int pshared, unsigned int value);

　　這是對由sem指定的信號量進(jìn)行初始化，設(shè)置好它的共享選項(xiàng)（linux只支持為0，即表示它是當(dāng)前進(jìn)程的局部信號量），然后給它一個(gè)初始值VALUE。

　　兩個(gè)原子操作函數(shù)：

　　int sem_wait(sem_t *sem);

　　int sem_post(sem_t *sem);

　　這兩個(gè)函數(shù)都要用一個(gè)由sem_init調(diào)用初始化的信號量對象的指針做參數(shù)。

　　sem_post：給信號量的值加1；

　　sem_wait:給信號量減1；對一個(gè)值為0的信號量調(diào)用sem_wait,這個(gè)函數(shù)將會(huì)等待直到有其它線程使它不再是0為止。

　　int sem_destroy(sem_t *sem);

　　這個(gè)函數(shù)的作用是再我們用完信號量后都它進(jìn)行清理。歸還自己占有的一切資源。

　　用信號量的方法實(shí)現(xiàn)生產(chǎn)者消費(fèi)者

　　這里使用4個(gè)信號量，其中兩個(gè)信號量occupied和empty分別用于解決生產(chǎn)者和消費(fèi)者線程之間的同步問題，pmut和cmut是用于這兩個(gè)線程之間的互斥問題。其中empty初始化為N（有界緩區(qū)的空間元數(shù)），occupied初始化為0，pmut和cmut初始化為1。

　　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 buffer)
{
 sem_init(&buffer.occupied, 0, 0);
 sem_init(&buffer.empty,0, BSIZE);
 sem_init(&buffer.pmut, 0, 1);
 sem_init(&buffer.cmut, 0, 1);
 buffer.nextin = buffer.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);
}

最新評論