linux的mutex的頭文件

A. linxuc++使用mutex需要什麼頭文件

mutex互斥鎖必須是普通鎖(PTHREAD_MUTEX_TIMED_NP)-01-07C++在linux下怎麼多線程12010-09

B. linux下mutex包含的在哪個頭文件

① 點擊菜單上的新建； ② 設置一個名稱，設置類型為 Linux，版本 Ubuntu(64 bit) 2 設置內存大小為2048 3 點擊下一步 4 點擊下一步 5 點擊下一步 6 設置硬碟40G

C. Linux POSIX編程如何查詢指定的線程是否阻塞

在主線程裡面設置一個定時器，或者sleep()你需要的時間長度，timeout後，去進行pthread_kill操作：
int kill_rc = pthread_kill(thread_id,0);
if(kill_rc == ESRCH)
printf("the specified thread did not exists or already quit\n");
else if(kill_rc == EINVAL)
printf("signal is invalid\n");
else
printf("the specified thread is alive\n");
同時，版子線程裡面處權理SIGKILL信號，signal(SIGKILL,sig_handler)，如果當時還沒有結束，就被強制結束了。

D. 通信的方式有多種，假設需要在Linux系

進程間的通信方式：
1.管道（pipe）及有名管道（named pipe）：
管道可用於具有親緣關系進程間的通信，有名管道除了具有管道所具有的功能外，它還允許無親緣關系進程間的通信。
2.信號（signal）：
信號是在軟體層次上對中斷機制的一種模擬，它是比較復雜的通信方式，用於通知進程有某事件發生，一個進程收到一個信號與處理器收到一個中斷請求效果上可以說是一致得。

3.消息隊列（message queue）：
消息隊列是消息的鏈接表，它克服了上兩種通信方式中信號量有限的缺點，具有寫許可權得進程可以按照一定得規則向消息隊列中添加新信息；對消息隊列有讀許可權得進程則可以從消息隊列中讀取信息。
消息緩沖通信技術是由Hansen首先提出的,其基本思想是:根據」生產者-消費者」原理,利用內存中公用消息緩沖區實現進程之間的信息交換.

內存中開辟了若干消息緩沖區,用以存放消息.每當一個進程向另一個進程發送消息時,便申請一個消息緩沖區,並把已准備好的消息送到緩沖區,然後把該消息緩沖區插入到接收進程的消息隊列中,最後通知接收進程.接收進程收到發送里程發來的通知後,從本進程的消息隊列中摘下一消息緩沖區,取出所需的信息,然後把消息緩沖區不定期給系統.系統負責管理公用消息緩沖區以及消息的傳遞.

一個進程可以給若干個進程發送消息,反之,一個進程可以接收不同進程發來的消息.顯然,進程中關於消息隊列的操作是臨界區.當發送進程正往接收進程的消息隊列中添加一條消息時,接收進程不能同時從該消息隊列中到出消息:反之也一樣.

消息緩沖區通信機制包含以下列內容:

(1) 消息緩沖區,這是一個由以下幾項組成的數據結構:
1、 消息長度
2、 消息正文
3、 發送者
4、 消息隊列指針

（2）消息隊列首指針m-q,一般保存在PCB中。
（1） 互斥信號量m-mutex,初值為1，用於互斥訪問消息隊列，在PCB中設置。
（2） 同步信號量m-syn,初值為0，用於消息計數，在PCB中設置。
（3） 發送消息原語send
（4） 接收消息原語receive(a)

4.共享內存（shared memory）：
可以說這是最有用的進程間通信方式。它使得多個進程可以訪問同一塊內存空間，不同進程可以及時看到對方進程中對共享內存中數據得更新。這種方式需要依靠某種同步操作，如互斥鎖和信號量等。
這種通信模式需要解決兩個問題：第一個問題是怎樣提供共享內存；第二個是公共內存的互斥關系則是程序開發人員的責任。
5.信號量（semaphore）：
主要作為進程之間及同一種進程的不同線程之間得同步和互斥手段。

6.套接字（socket）；
這是一種更為一般得進程間通信機制，它可用於網路中不同機器之間的進程間通信，應用非常廣泛。

http://blog.csdn.net/eroswang/archive/2007/09/04/1772350.aspx
linux下的進程間通信-詳解
詳細的講述進程間通信在這里絕對是不可能的事情，而且筆者很難有信心說自己對這一部分內容的認識達到了什麼樣的地步，所以在這一節的開頭首先向大家推薦著 名作者Richard Stevens的著名作品：《Advanced Programming in the UNIX Environment》，它的中文譯本《UNIX環境高級編程》已有機械工業出版社出版，原文精彩，譯文同樣地道，如果你的確對在Linux下編程有濃 厚的興趣，那麼趕緊將這本書擺到你的書桌上或計算機旁邊來。說這么多實在是難抑心中的景仰之情，言歸正傳，在這一節里，我們將介紹進程間通信最最初步和最 最簡單的一些知識和概念。
首先，進程間通信至少可以通過傳送打開文件來實現，不同的進程通過一個或多個文件來傳遞信息，事實上，在很多應用系統里，都使用了這種方法。但一般說來， 進程間通信（IPC：InterProcess Communication）不包括這種似乎比較低級的通信方法。Unix系統中實現進程間通信的方法很多，而且不幸的是，極少方法能在所有的Unix系 統中進行移植（唯一一種是半雙工的管道，這也是最原始的一種通信方式）。而Linux作為一種新興的操作系統，幾乎支持所有的Unix下常用的進程間通信 方法：管道、消息隊列、共享內存、信號量、套介面等等。下面我們將逐一介紹。

2.3.1 管道
管道是進程間通信中最古老的方式，它包括無名管道和有名管道兩種，前者用於父進程和子進程間的通信，後者用於運行於同一台機器上的任意兩個進程間的通信。
無名管道由pipe（）函數創建：
#include <unistd.h>
int pipe(int filedis[2])；
參數filedis返回兩個文件描述符：filedes[0]為讀而打開，filedes[1]為寫而打開。filedes[1]的輸出是filedes[0]的輸入。下面的例子示範了如何在父進程和子進程間實現通信。

#define INPUT 0
#define OUTPUT 1

void main() {
int file_descriptors[2];
/*定義子進程號 */
pid_t pid;
char buf[256];
int returned_count;
/*創建無名管道*/
pipe(file_descriptors);
/*創建子進程*/
if((pid = fork()) == -1) {
printf("Error in fork\n");
exit(1);
}
/*執行子進程*/
if(pid == 0) {
printf("in the spawned (child) process...\n");
/*子進程向父進程寫數據，關閉管道的讀端*/
close(file_descriptors[INPUT]);
write(file_descriptors[OUTPUT], "test data", strlen("test data"));
exit(0);
} else {
/*執行父進程*/
printf("in the spawning (parent) process...\n");
/*父進程從管道讀取子進程寫的數據，關閉管道的寫端*/
close(file_descriptors[OUTPUT]);
returned_count = read(file_descriptors[INPUT], buf, sizeof(buf));
printf("%d bytes of data received from spawned process: %s\n",
returned_count, buf);
}
}
在Linux系統下，有名管道可由兩種方式創建：命令行方式mknod系統調用和函數mkfifo。下面的兩種途徑都在當前目錄下生成了一個名為myfifo的有名管道：
方式一：mkfifo("myfifo","rw");
方式二：mknod myfifo p
生成了有名管道後，就可以使用一般的文件I/O函數如open、close、read、write等來對它進行操作。下面即是一個簡單的例子，假設我們已經創建了一個名為myfifo的有名管道。
/* 進程一：讀有名管道*/
#include <stdio.h>
#include <unistd.h>
void main() {
FILE * in_file;
int count = 1;
char buf[80];
in_file = fopen("mypipe", "r");
if (in_file == NULL) {
printf("Error in fdopen.\n");
exit(1);
}
while ((count = fread(buf, 1, 80, in_file)) > 0)
printf("received from pipe: %s\n", buf);
fclose(in_file);
}
/* 進程二：寫有名管道*/
#include <stdio.h>
#include <unistd.h>
void main() {
FILE * out_file;
int count = 1;
char buf[80];
out_file = fopen("mypipe", "w");
if (out_file == NULL) {
printf("Error opening pipe.");
exit(1);
}
sprintf(buf,"this is test data for the named pipe example\n");
fwrite(buf, 1, 80, out_file);
fclose(out_file);
}

2.3.2 消息隊列
消息隊列用於運行於同一台機器上的進程間通信，它和管道很相似，是一個在系統內核中用來保存消息的隊列，它在系統內核中是以消息鏈表的形式出現。消息鏈表中節點的結構用msg聲明。
事實上，它是一種正逐漸被淘汰的通信方式，我們可以用流管道或者套介面的方式來取代它，所以，我們對此方式也不再解釋，也建議讀者忽略這種方式。

2.3.3 共享內存
共享內存是運行在同一台機器上的進程間通信最快的方式，因為數據不需要在不同的進程間復制。通常由一個進程創建一塊共享內存區，其餘進程對這塊內存區進行 讀寫。得到共享內存有兩種方式：映射/dev/mem設備和內存映像文件。前一種方式不給系統帶來額外的開銷，但在現實中並不常用，因為它控制存取的將是 實際的物理內存，在Linux系統下，這只有通過限制Linux系統存取的內存才可以做到，這當然不太實際。常用的方式是通過shmXXX函數族來實現利 用共享內存進行存儲的。
首先要用的函數是shmget，它獲得一個共享存儲標識符。

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int shmget(key_t key, int size, int flag);
這個函數有點類似大家熟悉的malloc函數，系統按照請求分配size大小的內存用作共享內存。Linux系統內核中每個IPC結構都有的一個非負整數 的標識符，這樣對一個消息隊列發送消息時只要引用標識符就可以了。這個標識符是內核由IPC結構的關鍵字得到的，這個關鍵字，就是上面第一個函數的 key。數據類型key_t是在頭文件sys/types.h中定義的，它是一個長整形的數據。在我們後面的章節中，還會碰到這個關鍵字。

當共享內存創建後，其餘進程可以調用shmat（）將其連接到自身的地址空間中。
void *shmat(int shmid, void *addr, int flag);
shmid為shmget函數返回的共享存儲標識符，addr和flag參數決定了以什麼方式來確定連接的地址，函數的返回值即是該進程數據段所連接的實際地址，進程可以對此進程進行讀寫操作。
使用共享存儲來實現進程間通信的注意點是對數據存取的同步，必須確保當一個進程去讀取數據時，它所想要的數據已經寫好了。通常，信號量被要來實現對共享存 儲數據存取的同步，另外，可以通過使用shmctl函數設置共享存儲內存的某些標志位如SHM_LOCK、SHM_UNLOCK等來實現。

2.3.4 信號量
信號量又稱為信號燈，它是用來協調不同進程間的數據對象的，而最主要的應用是前一節的共享內存方式的進程間通信。本質上，信號量是一個計數器，它用來記錄對某個資源（如共享內存）的存取狀況。一般說來，為了獲得共享資源，進程需要執行下列操作：
（1） 測試控制該資源的信號量。
（2） 若此信號量的值為正，則允許進行使用該資源。進程將信號量減1。
（3） 若此信號量為0，則該資源目前不可用，進程進入睡眠狀態，直至信號量值大於0，進程被喚醒，轉入步驟（1）。
（4） 當進程不再使用一個信號量控制的資源時，信號量值加1。如果此時有進程正在睡眠等待此信號量，則喚醒此進程。
維護信號量狀態的是Linux內核操作系統而不是用戶進程。我們可以從頭文件/usr/src/linux/include/linux/sem.h 中看到內核用來維護信號量狀態的各個結構的定義。信號量是一個數據集合，用戶可以單獨使用這一集合的每個元素。要調用的第一個函數是semget，用以獲 得一個信號量ID。

struct sem {
short sempid;/* pid of last operaton */
ushort semval;/* current value */
ushort semncnt;/* num procs awaiting increase in semval */
ushort semzcnt;/* num procs awaiting semval = 0 */
}

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int flag);

key是前面講過的IPC結構的關鍵字，flag將來決定是創建新的信號量集合，還是引用一個現有的信號量集合。nsems是該集合中的信號量數。如果是創建新 集合（一般在伺服器中），則必須指定nsems；如果是引用一個現有的信號量集合（一般在客戶機中）則將nsems指定為0。

semctl函數用來對信號量進行操作。
int semctl(int semid, int semnum, int cmd, union semun arg);
不同的操作是通過cmd參數來實現的，在頭文件sem.h中定義了7種不同的操作，實際編程時可以參照使用。

semop函數自動執行信號量集合上的操作數組。
int semop(int semid, struct sembuf semoparray[], size_t nops);
semoparray是一個指針，它指向一個信號量操作數組。nops規定該數組中操作的數量。

下面，我們看一個具體的例子，它創建一個特定的IPC結構的關鍵字和一個信號量，建立此信號量的索引，修改索引指向的信號量的值，最後我們清除信號量。在下面的代碼中，函數ftok生成我們上文所說的唯一的IPC關鍵字。

#include <stdio.h>
#include <sys/types.h>
#include <sys/sem.h>
#include <sys/ipc.h>
void main() {
key_t unique_key; /* 定義一個IPC關鍵字*/
int id;
struct sembuf lock_it;
union semun options;
int i;

unique_key = ftok(".", 'a'); /* 生成關鍵字，字元'a'是一個隨機種子*/
/* 創建一個新的信號量集合*/
id = semget(unique_key, 1, IPC_CREAT | IPC_EXCL | 0666);
printf("semaphore id=%d\n", id);
options.val = 1; /*設置變數值*/
semctl(id, 0, SETVAL, options); /*設置索引0的信號量*/

/*列印出信號量的值*/
i = semctl(id, 0, GETVAL, 0);
printf("value of semaphore at index 0 is %d\n", i);

/*下面重新設置信號量*/
lock_it.sem_num = 0; /*設置哪個信號量*/
lock_it.sem_op = -1; /*定義操作*/
lock_it.sem_flg = IPC_NOWAIT; /*操作方式*/
if (semop(id, &lock_it, 1) == -1) {
printf("can not lock semaphore.\n");
exit(1);
}

i = semctl(id, 0, GETVAL, 0);
printf("value of semaphore at index 0 is %d\n", i);

/*清除信號量*/
semctl(id, 0, IPC_RMID, 0);
}

semget()

可以使用系統調用semget()創建一個新的信號量集，或者存取一個已經存在的信號量集：
系統調用：semget();
原型：intsemget(key_t key,int nsems,int semflg);
返回值：如果成功，則返回信號量集的IPC標識符。如果失敗，則返回-1：errno=EACCESS(沒有許可權)
EEXIST(信號量集已經存在，無法創建)
EIDRM(信號量集已經刪除)
ENOENT(信號量集不存在，同時沒有使用IPC_CREAT)
ENOMEM(沒有足夠的內存創建新的信號量集)
ENOSPC(超出限制)
系統調用semget()的第一個參數是關鍵字值（一般是由系統調用ftok()返回的）。系統內核將此值和系統中存在的其他的信號量集的關鍵字值進行比較。打開和存取操作與參數semflg中的內容相關。IPC_CREAT如果信號量集在系統內核中不存在，則創建信號量集。IPC_EXCL當和 IPC_CREAT一同使用時，如果信號量集已經存在，則調用失敗。如果單獨使用IPC_CREAT，則semget()要麼返回新創建的信號量集的標識符，要麼返回系統中已經存在的同樣的關鍵字值的信號量的標識符。如果IPC_EXCL和IPC_CREAT一同使用，則要麼返回新創建的信號量集的標識符，要麼返回-1。IPC_EXCL單獨使用沒有意義。參數nsems指出了一個新的信號量集中應該創建的信號量的個數。信號量集中最多的信號量的個數是在linux/sem.h中定義的：
#defineSEMMSL32/*<=512maxnumofsemaphoresperid*/
下面是一個打開和創建信號量集的程序：
intopen_semaphore_set(key_t keyval,int numsems)
{
intsid;
if(!numsems)
return(-1);
if((sid=semget(mykey,numsems,IPC_CREAT|0660))==-1)
{
return(-1);
}
return(sid);
}
};
==============================================================
semop()

系統調用：semop();
調用原型：int semop(int semid,struct sembuf*sops,unsign ednsops);
返回值：0，如果成功。-1，如果失敗：errno=E2BIG(nsops大於最大的ops數目)
EACCESS(許可權不夠)
EAGAIN(使用了IPC_NOWAIT，但操作不能繼續進行)
EFAULT(sops指向的地址無效)
EIDRM(信號量集已經刪除)
EINTR(當睡眠時接收到其他信號)
EINVAL(信號量集不存在,或者semid無效)
ENOMEM(使用了SEM_UNDO,但無足夠的內存創建所需的數據結構)
ERANGE(信號量值超出范圍)
第一個參數是關鍵字值。第二個參數是指向將要操作的數組的指針。第三個參數是數組中的操作的個數。參數sops指向由sembuf組成的數組。此數組是在linux/sem.h中定義的：
/*semop systemcall takes an array of these*/
structsembuf{
ushortsem_num;/*semaphore index in array*/
shortsem_op;/*semaphore operation*/
shortsem_flg;/*operation flags*/
sem_num將要處理的信號量的個數。
sem_op要執行的操作。
sem_flg操作標志。
如果sem_op是負數，那麼信號量將減去它的值。這和信號量控制的資源有關。如果沒有使用IPC_NOWAIT，那麼調用進程將進入睡眠狀態，直到信號量控制的資源可以使用為止。如果sem_op是正數，則信號量加上它的值。這也就是進程釋放信號量控制的資源。最後，如果sem_op是0，那麼調用進程將調用sleep()，直到信號量的值為0。這在一個進程等待完全空閑的資源時使用。
===============================================================
semctl()

系統調用：semctl();
原型：int semctl(int semid,int semnum,int cmd,union semunarg);
返回值：如果成功，則為一個正數。
如果失敗，則為-1：errno=EACCESS(許可權不夠)
EFAULT(arg指向的地址無效)
EIDRM(信號量集已經刪除)
EINVAL(信號量集不存在，或者semid無效)
EPERM(EUID沒有cmd的權利)
ERANGE(信號量值超出范圍)
系統調用semctl用來執行在信號量集上的控制操作。這和在消息隊列中的系統調用msgctl是十分相似的。但這兩個系統調用的參數略有不同。因為信號量一般是作為一個信號量集使用的，而不是一個單獨的信號量。所以在信號量集的操作中，不但要知道IPC關鍵字值，也要知道信號量集中的具體的信號量。這兩個系統調用都使用了參數cmd，它用來指出要操作的具體命令。兩個系統調用中的最後一個參數也不一樣。在系統調用msgctl中，最後一個參數是指向內核中使用的數據結構的指針。我們使用此數據結構來取得有關消息隊列的一些信息，以及設置或者改變隊列的存取許可權和使用者。但在信號量中支持額外的可選的命令，這樣就要求有一個更為復雜的數據結構。
系統調用semctl()的第一個參數是關鍵字值。第二個參數是信號量數目。
參數cmd中可以使用的命令如下：
·IPC_STAT讀取一個信號量集的數據結構semid_ds，並將其存儲在semun中的buf參數中。
·IPC_SET設置信號量集的數據結構semid_ds中的元素ipc_perm，其值取自semun中的buf

E. 如何利用Video4Linux獲取攝像頭數據

1. 攝像頭的安裝

在Linux下常用的攝像頭驅動是spca5xx。這個網站還給出了這款驅動支持的攝像頭的種類。另外，ov511晶元直接就支持Linux，使用者款晶元的攝像頭有網眼V2000。我使用的是網眼V2000的攝像頭，和Z-Star
301p+現代7131R晶元的攝像頭。後一種需要spca5xx的驅動。關於spca5xx的安裝方法，網上有很多介紹，這里就不說了。

2. 攝像頭的調試

安裝好攝像頭後，為了測試攝像頭能否正常工作，可以用一下軟體。比較著名的是xawtv，在網上搜以下可以下載到。安裝好後，打開xawtv則可以調試攝像頭。

3. Video4Linux 編程獲取數據

現有的video4linux有兩個版本，v4l和v4l2。本文主要是關於v4l的編程。利用v4l API獲取視頻圖像一般有以下幾步：

a> 打開設備

b> 設置設備的屬性，比如圖像的亮度，對比度等等

c> 設定傳輸格式和傳輸方式

d> 開始傳輸數據，一般是一個循環，用以連續的傳輸數據

e> 關閉設備

下面具體介紹v4l編程的過程。首先指出，在video4linux編程時要包含頭文件，其中包含了video4linux的數據結構和函數定義。

1）v4l的數據結構

在video4linux API中定義了如下數據結構，詳細的數據結構定義可以參考v4l API的文檔，這里就編程中經常使用的數據結構作出說明。

首先我們定義一個描述設備的數據結構，它包含了v4l中定義的所有數據結構：
typedef struct
_v4ldevice
{int fd;//設備號
struct video_capability capability;
struct
video_channel channel[10];
struct video_picture picture;
struct video_clip
clip;
struct video_window window;
struct video_capture capture;
struct
video_buffer buffer;
struct video_mmap mmap;
struct video_mbuf
mbuf;
struct video_unit unit;
unsigned char
*map;//mmap方式獲取數據時，數據的首地址
pthread_mutex_t mutex;
int frame;
int
framestat[2];
int overlay;
}v4ldevice;
下面解釋上面這個數據結構中包含的數據結構，這些結構的定義都在中。
* struct
video_capability
name[32] Canonical name for this interface
type Type of
interface
channels Number of radio/tv channels if appropriate
audios
Number of audio devices if appropriate
maxwidth Maximum capture width in
pixels
maxheight Maximum capture height in pixels
minwidth Minimum capture
width in pixels
minheight Minimum capture height in pixels

這一個數據結構是包含了攝像頭的屬性，name是攝像頭的名字，maxwidth maxheight是攝像頭所能獲取的最大圖像大小，用像素作單位。

在程序中，通過ioctl函數的VIDIOCGCAP控制命令讀寫設備通道已獲取這個結構，有關ioctl的使用，比較復雜，這里就不說了。下面列出獲取這一數據結構的代碼：
int v4lgetcapability(v4ldevice *vd)
{
if(ioctl(vd->fd,
VIDIOCGCAP, &(vd->capability)) < 0)
{
v4lperror("v4lopen:VIDIOCGCAP");
return -1;
}
return 0;
}
*
struct video_picture
brightness Picture brightness
hue Picture hue (colour
only)
colour Picture colour (colour only)
contrast Picture
contrast
whiteness The whiteness (greyscale only)
depth The capture depth
(may need to match the frame buffer depth)
palette Reports the palette that
should be used for this image

這個數據結構主要定義了圖像的屬性，諸如亮度，對比度，等等。這一結構的獲取通過ioctl發出VIDIOCGPICT控制命令獲取。
* struct video_mbuf
size The number of bytes to
map
frames The number of frames
offsets The offset of each frame

這個數據結構在用mmap方式獲取數據時很重要:

size表示圖像的大小，如果是640*480的彩色圖像，size=640*480*3

frames表示幀數

offsets表示每一幀在內存中的偏移地址，通過這個值可以得到數據在圖像中的地址。

得到這個結構的數據可以用ioctl的VIDIOCGMBUF命令。源碼如下：
int v4lgetmbuf(v4ldevice
*vd)
{
if(ioctl(vd->fd, VIDIOCGMBUF, &(vd->mbuf))<0)
{
v4lperror("v4lgetmbuf:VIDIOCGMBUF");
return -1;
}
return
0;
}

而數據的地址可以有以下方式計算：
unsigned char
*v4lgetaddress(v4ldevice *vd)
{
return (vd->map +
vd->mbuf.offsets[vd->frame]);
}

2）獲取影像mmap方式。

在video4Linux下獲取影像有兩種方式：overlay和mmap。由於我的攝像頭不支持overlay方式，所以這里只談mmap方式。

mmap方式是通過內存映射的方式獲取數據，系統調用ioctl的VIDIOCMCAPTURE後，將圖像映射到內存中，然後可以通過前面的v4lgetmbuf(vd)函數和v4lgetaddress(vd)函數獲得數據的首地址，這是李可以選擇是將它顯示出來還是放到別的什麼地方。

下面給出獲取連續影像的最簡單的方法（為了簡化，將一些可去掉的屬性操作都去掉了）：
char*
devicename="/dev/video0";
char* buffer;
v4ldevice device;
int width =
640;
int height = 480;
int frame =
0;
v4lopen("/dev/video0",&device);//打開設備
v4lgrabinit(&device,width,height);//初始化設備，定義獲取的影像的大小
v4lmmap(&device);//內存映射
v4lgrabstart(&device,frame);//開始獲取影像
while(1){
v4lsync(&device,frame);//等待傳完一幀
frame
= (frame+1)%2;//下一幀的frame
v4lcapture(&device,frame);//獲取下一幀
buffer =
(char*)v4lgetaddress(&device);//得到這一幀的地址
//buffer給出了圖像的首地址，你可以選擇將圖像顯示或保存......
//圖像的大小為
width*height*3
..........................
}
轉載僅供參考，版權屬於原作者。祝你愉快，滿意請採納哦

F. linux互斥鎖問題

互斥說的是pthread_mutex_t這個么，可以在在用戶程序使用，一般配合條件變數pthread_cond_t使用；自旋鎖沒用過，我記得也可以用在用戶程序中~

G. Linux mutex為什麼不能用在中斷函數

Linux mutex不能用在中斷函數原因：Backtrace來看，應該是i2c_transfer中調用mutex_lock導致schele調用。

pthread_mutex_lock(&qlock);表示嘗試去把qlock上鎖，它會先判斷qlock是否已經上鎖，如果已經上鎖這個線程就會停在這一步直到其他線程把鎖解開。它才繼續運行。所以代碼中要麼是線程1先執行完後執行線程2，要麼就是線程2先執行，再執行線程1.而線程3一開始就執行了。

中斷函數防止方法：

要防止中斷沖突，其實就是要知道什麼設備容易產生中斷沖突，只要知道了這點，在使用這些設備時稍微注意一下就可以了。下面我列出一些容易沖突的設備，希望對讀者有用。

1、音效卡：一些早期的ISA型音效卡，系統很有可能不認，就需要用戶手動設置（一般為5）。

2、內置數據機和滑鼠：一般滑鼠用COM1，內置數據機使用COM2的中斷（一般為3），這時要注意此時COM2上不應有其它設備。

H. Linux 之mutex 源碼分析

 mutex相關的函數並不是linux kernel實現的，而是glibc實現的，源碼位於nptl目錄下。

http://ftp.gnu.org/pub/gnu/glibc/glibc-2.3.5.tar.gz

首先說數據結構：

typedef union

{

  struct

  {

    int __lock;

    unsigned int __count;

    int __owner;

    unsigned int __nusers;

    /* KIND must stay at this position in the structure to maintain

       binary compatibility.  */

    int __kind;

    int __spins;

  } __data;

  char __size[__SIZEOF_PTHREAD_MUTEX_T];

  long int __align;

} pthread_mutex_t;

 int __lock;  資源競爭引用計數

 int __kind; 鎖類型，init 函數中mutexattr 參數傳遞，該參數可以為NULL，一般為 PTHREAD_MUTEX_NORMAL

結構體其他元素暫時不了解，以後更新。

/*nptl/pthread_mutex_init.c*/

int

__pthread_mutex_init (mutex, mutexattr)

     pthread_mutex_t *mutex;

     const pthread_mutexattr_t *mutexattr;

{

  const struct pthread_mutexattr *imutexattr;

  assert (sizeof (pthread_mutex_t) <= __SIZEOF_PTHREAD_MUTEX_T);

  imutexattr = (const struct pthread_mutexattr *) mutexattr ?: &default_attr;

  /* Clear the whole variable.  */

  memset (mutex, '\0', __SIZEOF_PTHREAD_MUTEX_T);

  /* Copy the values from the attribute.  */

  mutex->__data.__kind = imutexattr->mutexkind & ~0x80000000;

  /* Default values: mutex not used yet.  */

  // mutex->__count = 0;        already done by memset

  // mutex->__owner = 0;        already done by memset

  // mutex->__nusers = 0;        already done by memset

  // mutex->__spins = 0;        already done by memset

  return 0;

}

init函數就比較簡單了，將mutex結構體清零，設置結構體中__kind屬性。

/*nptl/pthread_mutex_lock.c*/

int

__pthread_mutex_lock (mutex)

     pthread_mutex_t *mutex;

{

  assert (sizeof (mutex->__size) >= sizeof (mutex->__data));

  pid_t id = THREAD_GETMEM (THREAD_SELF, tid);

  switch (__builtin_expect (mutex->__data.__kind, PTHREAD_MUTEX_TIMED_NP))

    {

     …

    default:

      /* Correct code cannot set any other type.  */

    case PTHREAD_MUTEX_TIMED_NP:

    simple:

      /* Normal mutex.  */

      LLL_MUTEX_LOCK (mutex->__data.__lock);

      break;

  …

  }

  /* Record the ownership.  */

  assert (mutex->__data.__owner == 0);

  mutex->__data.__owner = id;

#ifndef NO_INCR

  ++mutex->__data.__nusers;

#endif

  return 0;

}

該函數主要是調用LLL_MUTEX_LOCK， 省略部分為根據mutex結構體__kind屬性不同值做些處理。

宏定義函數LLL_MUTEX_LOCK最終調用，將結構體mutex的__lock屬性作為參數傳遞進來

#define __lll_mutex_lock(futex)                                                \

  ((void) ({                                                                \

    int *__futex = (futex);                                                \

    if (atomic_compare_and_exchange_bool_acq (__futex, 1, 0) != 0)        \

      __lll_lock_wait (__futex);                                        \

  }))

atomic_compare_and_exchange_bool_acq (__futex, 1, 0)宏定義為：

#define atomic_compare_and_exchange_bool_acq(mem, newval, oldval) \

  ({ __typeof (mem) __gmemp = (mem);                                      \

     __typeof (*mem) __gnewval = (newval);                              \

      \

     *__gmemp == (oldval) ? (*__gmemp = __gnewval, 0) : 1; })

這個宏實現的功能是：

如果mem的值等於oldval，則把newval賦值給mem，放回0，否則不做任何處理，返回1.

由此可以看出，當mutex鎖限制的資源沒有競爭時，__lock 屬性被置為1，並返回0，不會調用__lll_lock_wait (__futex); 當存在競爭時，再次調用lock函數，該宏不做任何處理，返回1，調用__lll_lock_wait (__futex);

void

__lll_lock_wait (int *futex)

{

  do

    {

      int oldval = atomic_compare_and_exchange_val_acq (futex, 2, 1);

      if (oldval != 0)

lll_futex_wait (futex, 2);

    }

  while (atomic_compare_and_exchange_bool_acq (futex, 2, 0) != 0);

}

atomic_compare_and_exchange_val_acq (futex, 2, 1); 宏定義：

/* The only basic operation needed is compare and exchange.  */

#define atomic_compare_and_exchange_val_acq(mem, newval, oldval) \

  ({ __typeof (mem) __gmemp = (mem);                                      \

     __typeof (*mem) __gret = *__gmemp;                                      \

     __typeof (*mem) __gnewval = (newval);                              \

      \

     if (__gret == (oldval))                                              \

       *__gmemp = __gnewval;                                              \

     __gret; })

這個宏實現的功能是，當mem等於oldval時，將mem置為newval，始終返回mem原始值。

此時，futex等於1，futex將被置為2，並且返回1. 進而調用

lll_futex_wait (futex, 2);

#define lll_futex_timed_wait(ftx, val, timespec)                        \

({                                                                        \

   DO_INLINE_SYSCALL(futex, 4, (long) (ftx), FUTEX_WAIT, (int) (val),        \

     (long) (timespec));                                \

   _r10 == -1 ? -_retval : _retval;                                        \

})

該宏對於不同的平台架構會用不同的實現，採用匯編語言實現系統調用。不過確定的是調用了Linux kernel的futex系統調用。

futex在linux kernel的實現位於：kernel/futex.c

SYSCALL_DEFINE6(futex, u32 __user *, uaddr, int, op, u32, val,

struct timespec __user *, utime, u32 __user *, uaddr2,

u32, val3)

{

struct timespec ts;

ktime_t t, *tp = NULL;

u32 val2 = 0;

int cmd = op & FUTEX_CMD_MASK;

if (utime && (cmd == FUTEX_WAIT || cmd == FUTEX_LOCK_PI ||

      cmd == FUTEX_WAIT_BITSET ||

      cmd == FUTEX_WAIT_REQUEUE_PI)) {

if (_from_user(&ts, utime, sizeof(ts)) != 0)

return -EFAULT;

if (!timespec_valid(&ts))

return -EINVAL;

t = timespec_to_ktime(ts);

if (cmd == FUTEX_WAIT)

t = ktime_add_safe(ktime_get(), t);

tp = &t;

}

/*

 * requeue parameter in 'utime' if cmd == FUTEX_*_REQUEUE_*.

 * number of waiters to wake in 'utime' if cmd == FUTEX_WAKE_OP.

 */

if (cmd == FUTEX_REQUEUE || cmd == FUTEX_CMP_REQUEUE ||

    cmd == FUTEX_CMP_REQUEUE_PI || cmd == FUTEX_WAKE_OP)

val2 = (u32) (unsigned long) utime;

return do_futex(uaddr, op, val, tp, uaddr2, val2, val3);

}

futex具有六個形參，pthread_mutex_lock最終只關注了前四個。futex函數對參數進行判斷和轉化之後，直接調用do_futex。

long do_futex(u32 __user *uaddr, int op, u32 val, ktime_t *timeout,

u32 __user *uaddr2, u32 val2, u32 val3)

{

int clockrt, ret = -ENOSYS;

int cmd = op & FUTEX_CMD_MASK;

int fshared = 0;

if (!(op & FUTEX_PRIVATE_FLAG))

fshared = 1;

clockrt = op & FUTEX_CLOCK_REALTIME;

if (clockrt && cmd != FUTEX_WAIT_BITSET && cmd != FUTEX_WAIT_REQUEUE_PI)

return -ENOSYS;

switch (cmd) {

case FUTEX_WAIT:

val3 = FUTEX_BITSET_MATCH_ANY;

case FUTEX_WAIT_BITSET:

ret = futex_wait(uaddr, fshared, val, timeout, val3, clockrt);

break;

         …

default:

ret = -ENOSYS;

}

return ret;

}

省略部分為對其他cmd的處理，pthread_mutex_lock函數最終傳入的cmd參數為FUTEX_WAIT，所以在此只關注此分之，分析futex_wait函數的實現。

static int futex_wait(u32 __user *uaddr, int fshared,

      u32 val, ktime_t *abs_time, u32 bitset, int clockrt)

{

struct hrtimer_sleeper timeout, *to = NULL;

struct restart_block *restart;

struct futex_hash_bucket *hb;

struct futex_q q;

int ret;

           … … //delete parameters check and convertion

retry:

/* Prepare to wait on uaddr. */

ret = futex_wait_setup(uaddr, val, fshared, &q, &hb);

if (ret)

goto out;

/* queue_me and wait for wakeup, timeout, or a signal. */

futex_wait_queue_me(hb, &q, to);

… … //other handlers

return ret;

}

futex_wait_setup 將線程放進休眠隊列中，

futex_wait_queue_me(hb, &q, to);將本線程休眠，等待喚醒。

喚醒後，__lll_lock_wait函數中的while (atomic_compare_and_exchange_bool_acq (futex, 2, 0) != 0); 語句將被執行，由於此時futex在pthread_mutex_unlock中置為0，所以atomic_compare_and_exchange_bool_acq (futex, 2, 0)語句將futex置為2，返回0. 退出循環，訪問用戶控制項的臨界資源。

/*nptl/pthread_mutex_unlock.c*/

int

internal_function attribute_hidden

__pthread_mutex_unlock_usercnt (mutex, decr)

     pthread_mutex_t *mutex;

     int decr;

{

  switch (__builtin_expect (mutex->__data.__kind, PTHREAD_MUTEX_TIMED_NP))

    {

   … …

    default:

      /* Correct code cannot set any other type.  */

    case PTHREAD_MUTEX_TIMED_NP:

    case PTHREAD_MUTEX_ADAPTIVE_NP:

      /* Normal mutex.  Nothing special to do.  */

      break;

    }

  /* Always reset the owner field.  */

  mutex->__data.__owner = 0;

  if (decr)

    /* One less user.  */

    --mutex->__data.__nusers;

  /* Unlock.  */

  lll_mutex_unlock (mutex->__data.__lock);

  return 0;

}

省略部分是針對不同的__kind屬性值做的一些處理，最終調用 lll_mutex_unlock。

該宏函數最終的定義為：

#define __lll_mutex_unlock(futex)                        \

  ((void) ({                                                \

    int *__futex = (futex);                                \

    int __val = atomic_exchange_rel (__futex, 0);        \

\

    if (__builtin_expect (__val > 1, 0))                \

      lll_futex_wake (__futex, 1);                        \

  }))

atomic_exchange_rel (__futex, 0);宏為：

#define atomic_exchange_rel(mem, value) \

  (__sync_synchronize (), __sync_lock_test_and_set (mem, value))

實現功能為：將mem設置為value，返回原始mem值。

__builtin_expect (__val > 1, 0) 是編譯器優化語句，告訴編譯器期望值，也就是大多數情況下__val > 1 ？是0，其邏輯判斷依然為if(__val > 1)為真的話執行 lll_futex_wake。

現在分析，在資源沒有被競爭的情況下，__futex 為1，那麼返回值__val則為1，那麼 lll_futex_wake (__futex, 1);        不會被執行，不產生系統調用。 當資源產生競爭的情況時，根據對pthread_mutex_lock 函數的分析，__futex為2， __val則為2，執行 lll_futex_wake (__futex, 1); 從而喚醒等在臨界資源的線程。

lll_futex_wake (__futex, 1); 最終會調動同一個系統調用，即futex, 只是傳遞的cmd參數為FUTEX_WAKE。

在linux kernel的futex實現中，調用

static int futex_wake(u32 __user *uaddr, int fshared, int nr_wake, u32 bitset)

{

struct futex_hash_bucket *hb;

struct futex_q *this, *next;

struct plist_head *head;

union futex_key key = FUTEX_KEY_INIT;

int ret;

if (!bitset)

return -EINVAL;

ret = get_futex_key(uaddr, fshared, &key);

if (unlikely(ret != 0))

goto out;

hb = hash_futex(&key);

spin_lock(&hb->lock);

head = &hb->chain;

plist_for_each_entry_safe(this, next, head, list) {

if (match_futex (&this->key, &key)) {

if (this->pi_state || this->rt_waiter) {

ret = -EINVAL;

break;

}

/* Check if one of the bits is set in both bitsets */

if (!(this->bitset & bitset))

continue;

wake_futex(this);

if (++ret >= nr_wake)

break;

}

}

spin_unlock(&hb->lock);

put_futex_key(fshared, &key);

out:

return ret;

}

該函數遍歷在該mutex上休眠的所有線程，調用wake_futex進行喚醒，

static void wake_futex(struct futex_q *q)

{

struct task_struct *p = q->task;

/*

 * We set q->lock_ptr = NULL _before_ we wake up the task. If

 * a non futex wake up happens on another CPU then the task

 * might exit and p would dereference a non existing task

 * struct. Prevent this by holding a reference on p across the

 * wake up.

 */

get_task_struct(p);

plist_del(&q->list, &q->list.plist);

/*

 * The waiting task can free the futex_q as soon as

 * q->lock_ptr = NULL is written, without taking any locks. A

 * memory barrier is required here to prevent the following

 * store to lock_ptr from getting ahead of the plist_del.

 */

smp_wmb();

q->lock_ptr = NULL;

wake_up_state(p, TASK_NORMAL);

put_task_struct(p);

}

wake_up_state(p, TASK_NORMAL);  的實現位於kernel/sched.c中，屬於linux進程調度的技術。

I. 如何對讀寫鎖進行處理

信號量強調的是線程（或進程）間的同步：「信號量用在多線程多任務同步的，一個線程完成了某一個動作就通過信號量告訴別的線程，別的線程再進行某些動作（大家都 在sem_wait的時候，就阻塞在那裡）。當信號量為單值信號量是，也可以完成一個資源的互斥訪問。

有名信號量：可以用於不同進程間或多線程間的互斥與同步

創建打開有名信號量

sem_t *sem_open(const char *name, int oflag);

sem_t *sem_open(const char *name, int oflag, mode_t mode, unsigned int value);

成功返回信號量指針；失敗返回SEM_FAILED，設置errnoname是文件路徑名,但不能寫成/tmp/a.sem這樣的形式,因為在linux下,sem都是在/dev/shm目錄下,可寫成"/mysem"或"mysem",創建出來的文件都 是"/dev/shm/sem.mysem",mode設置為0666，value設置為信號量的初始值.所需信號燈等已存在條件下指定O_CREAT|O_EXCL卻是個錯誤。

關閉信號量，進程終止時，會自動調用它

int sem_close(sem_t *sem);

成功返回0；失敗返回-1，設置errno

刪除信號量，立即刪除信號量名字，當其他進程都關閉它時，銷毀它

int sem_unlink(const char *name);

等待信號量，測試信號量的值，如果其值小於或等於0，那麼就等待（阻塞）；一旦其值變為大於0就將它減1，並返回

int sem_wait(sem_t *sem);

int sem_trywait(sem_t *sem);

成功返回0；失敗返回-1，設置errno

當信號量的值為0時，sem_trywait立即返回，設置errno為EAGAIN。如果被某個信號中斷，sem_wait會過早地返回，設置errno為EINTR

發出信號量，給它的值加1，然後喚醒正在等待該信號量的進程或線程

int sem_post(sem_t *sem);

成功返回0；失敗返回-1，不會改變它的值，設置errno，該函數是非同步信號安全的，可以在信號處理程序里調用它無名信號量，用於進程體內各線程間的互斥和同步,使用如下API(無名信號量,基於內存的信號量)

（1）、sem_init

功能：用於創建一個信號量，並初始化信號量的值。

頭文件：

函數原型： int sem_init (sem_t* sem, int pshared, unsigned int value);

函數傳入值： sem:信號量。pshared:決定信號量能否在幾個進程間共享。由於目前LINUX還沒有實現進程間共享信息量，所以這個值只能取0。

（2）其他函數。

int sem_wait (sem_t* sem);

int sem_trywait (sem_t* sem);

int sem_post (sem_t* sem);

int sem_getvalue (sem_t* sem);

int sem_destroy (sem_t* sem);

功能：sem_wait和sem_trywait相當於P操作，它們都能將信號量的值減一，兩者的區別在於若信號量的值小於零時，sem_wait將會阻塞進程，而sem_trywait則會立即返回。sem_post相當於V操作，它將信號量的值加一，同時發出喚醒的信號給等待的進程（或線程）。

sem_getvalue 得到信號量的值。

sem_destroy 摧毀信號量。

如果某個基於內存的信號燈是在不同進程間同步的，該信號燈必須存放在共享內存區中，這要只要該共享內存區存在，該信號燈就存在。

互斥鎖(又名互斥量）強調的是資源的訪問互斥：互斥鎖是用在多線程多任務互斥的，一個線程佔用了某一個資源，那麼別的線程就無法訪問，直到這個線程unlock，其他的線程才開始可以利用這個資源。比如對全局變數的訪問，有時要加鎖，操作完了，在解鎖。有的時候鎖和信號量會同時使用的」

也就是說，信號量不一定是鎖定某一個資源，而是流程上的概念，比如：有A,B兩個線程，B線程要等A線程完成某一任務以後再進行自己下面的步驟，這個任務並不一定是鎖定某一資源，還可以是進行一些計算或者數據處理之類。而線程互斥量則是「鎖住某一資源」的概念，在鎖定期間內，其他線程無法對被保護的數據進行操作。在有些情況下兩者可以互換。

在linux下, 線程的互斥量數據類型是pthread_mutex_t. 在使用前, 要對它進行初始化:

對於靜態分配的互斥量, 可以把它設置為PTHREAD_MUTEX_INITIALIZER, 或者調用pthread_mutex_init.

對於動態分配的互斥量, 在申請內存(malloc)之後, 通過pthread_mutex_init進行初始化, 並且在釋放內存(free)前需要調用pthread_mutex_destroy.

原型:

int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restric attr);

int pthread_mutex_destroy(pthread_mutex_t *mutex);

頭文件:

返回值: 成功則返回0, 出錯則返回錯誤編號.

說明: 如果使用默認的屬性初始化互斥量, 只需把attr設為NULL. 其他值在以後講解.

首先說一下加鎖函數:

頭文件:

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

返回值: 成功則返回0, 出錯則返回錯誤編號.

說 明: 具體說一下trylock函數, 這個函數是非阻塞調用模式, 也就是說, 如果互斥量沒被鎖住, trylock函數將把互斥量加鎖, 並獲得對共享資源的訪問許可權; 如果互斥量 被鎖住了, trylock函數將不會阻塞等待而直接返回EBUSY, 表示共享資源處於忙狀態.

再說一下解所函數:

頭文件:

原型: int pthread_mutex_unlock(pthread_mutex_t *mutex);

返回值: 成功則返回0, 出錯則返回錯誤編號.

條件變數常與互斥鎖同時使用，達到線程同步的目的：條件變數通過允許線程阻塞和等待另一個線程發送信號的方法彌補了互斥鎖的不足。在發 送信號時，如果沒有線程 等待在該條件變數上，那麼信號將丟失；而信號量有計數值，每次信號量post操作都會被記錄

1. 互斥鎖必須是誰上鎖就由誰來解鎖，而信號量的wait和post操作不必由同一個線程執行。

3. 2. 互斥鎖要麼被鎖住，要麼被解開，和二值信號量類似

5. 3. sem_post是各種同步技巧中，唯一一個能在信號處理程序中安全調用的函數

7. 4. 互斥鎖是為上鎖而優化的；條件變數是為等待而優化的； 信號量既可用於上鎖，也可用於等待，因此會有更多的開銷和更高的復雜性

9. 5. 互斥鎖，條件變數都只用於同一個進程的各線程間，而信號量（有名信號量）可用於不同進程間的同步。當信號量用於進程間同步時，要求信號量建立在共享內存區。

11. 6. 信號量有計數值，每次信號量post操作都會被記錄，而條件變數在發送信號時，如果沒有線程在等待該條件變數，那麼信號將丟失。

13. 讀寫鎖

15. 讀寫鎖與互斥量類似，不過讀寫鎖允許更高的並行性。互斥量要麼是鎖住狀態要麼是不加鎖狀態，而且一次只有一個線程可以對其加鎖。

17. 讀寫鎖可以由三種狀態：讀模式下加鎖狀態、寫模式下加鎖狀態、不加鎖狀態。一次只有一個線程可以佔有寫模式的讀寫鎖，但是多個線程可以同時佔有讀模式的讀寫

18. 鎖。

20. 在讀寫鎖是寫加鎖狀態時，在這個鎖被解鎖之前，所有試圖對這個鎖加鎖的線程都會被阻塞。當讀寫鎖在讀加鎖狀態時，所有試圖以讀模式對它進行加鎖的線程都可以得到訪問權，但是如果線程希望以寫模式對此鎖進行加鎖，它必須阻塞直到所有的線程釋放讀鎖。雖然讀寫鎖的實現各不相同，但當讀寫鎖處於讀模式鎖住狀態時，如果有另外的線程試圖以寫模式加鎖，讀寫鎖通常會阻塞隨後的讀模式鎖請求。這樣可以避免讀模式鎖長期佔用，而等待的寫模式鎖請求一直得不到滿足。

22. 讀寫鎖非常適合於對數據結構讀的次數遠大於寫的情況。當讀寫鎖在寫模式下時，它所保護的數據結構就可以被安全地修改，因為當前只有一個線程可以在寫模式下擁 有這個鎖。當讀寫鎖在讀狀態下時，只要線程獲取了讀模式下的讀寫鎖，該鎖所保護的數據結構可以被多個獲得讀模式鎖的線程讀取。

24. 讀寫鎖也叫做共享-獨占鎖，當讀寫鎖以讀模式鎖住時，它是以共享模式鎖住的；當他以寫模式鎖住時，它是以獨占模式鎖住的。

25. 初始化和銷毀:

26. #include

27. int pthread_rwlock_init(pthread_rwlock_t *restrict rwlock, const pthread_rwlockattr_t *restrict attr);

28. int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);

30. 成功則返回0, 出錯則返回錯誤編號.

32. 同互斥量以上, 在釋放讀寫鎖佔用的內存之前, 需要先通過thread_rwlock_destroy對讀寫鎖進行清理工作, 釋放由init分配的資源.

34. 讀和寫:

35. #include

36. int pthread_rwlock_rdlock(pthread_rwlock_t *rwlock);

37. int pthread_rwlock_wrlock(pthread_rwlock_t *rwlock);

38. int pthread_rwlock_unlock(pthread_rwlock_t *rwlock);

40. 成功則返回0, 出錯則返回錯誤編號.

42. 這3個函數分別實現獲取讀鎖, 獲取寫鎖和釋放鎖的操作. 獲取鎖的兩個函數是阻塞操作, 同樣, 非阻塞的函數為:

43. #include

44. int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

45. int pthread_rwlock_trywrlock(pthread_rwlock_t *rwlock);

47. 成功則返回0, 出錯則返回錯誤編號.

49. 非阻塞的獲取鎖操作, 如果可以獲取則返回0, 否則返回錯誤的EBUSY.

51. 雖然讀寫鎖提高了並行性，但是就速度而言並不比互斥量快.

53. 可能這也是即使有讀寫鎖存在還會使用互斥量的原因，因為他在速度方面略勝一籌。這就需要我們在寫程序的時候綜合考慮速度和並行性並找到一個折中。

55. 比如： 假設使用互斥量需要0.5秒，使用讀寫鎖需要0.8秒。在類似學生管理系統這類中，可能百分之九十的時間都是查詢操作，那麼假如現在突然來個個20個請求，如果使用的是互斥量，那麼最後的那個查詢請求被滿足需要10後。這樣，估計沒人能受得了。而使用讀寫鎖，應為 讀鎖能夠多次獲得。所以所有的20個請求，每個請求都能在1秒左右得到滿足。

57. 也就是說，在一些寫操作比較多或是本身需要同步的地方並不多的程序中我們應該使用互斥量，而在讀操作遠大於寫操作的一些程序中我們應該使用讀寫鎖來進行同步

59. 條件變數(condition)

61. 條件變數與互斥量一起使用時，允許線程以無競爭的方式等待特定的條件發生。

63. 條件本身是由互斥量保護的。線程在改變條件狀態前必須首先鎖住互斥量，其它線程在獲得互斥量之前不會察覺到這種改變，因此必須鎖定互斥量以後才能計算條件。

65. 條件的檢測是在互斥鎖的保護下進行的。如果一個條件為假，一個線程自動阻塞，並釋放等待狀態改變的互斥鎖。如果另一個線程改變了條件，它發信號給關聯的條件

67. 變數，喚醒一個或多個等待它的線程，重新獲得互斥鎖，重新評價條件。如果兩進程共享可讀寫的內存，條件變數可以被用來實現這兩進程間的線程同步。

69. 1. 初始化:

71. 條件變數採用的數據類型是pthread_cond_t, 在使用之前必須要進行初始化, 這包括兩種方式:

73. 靜態: 可以把常量PTHREAD_COND_INITIALIZER給靜態分配的條件變數.

74. 動態: pthread_cond_init函數, 是釋放動態條件變數的內存空間之前, 要用pthread_cond_destroy對其進行清理.

75. #include

76. int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);

77. int pthread_cond_destroy(pthread_cond_t *cond);

79. 成功則返回0, 出錯則返回錯誤編號.

81. 注意：條件變數佔用的空間並未被釋放。

83. 當pthread_cond_init的attr參數為NULL時, 會創建一個默認屬性的條件變數; 非默認情況以後討論.

85. 2. 等待條件:

86. #include

87. int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restric mutex);

88. int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);

90. 成功則返回0, 出錯則返回錯誤編號.

92. 這兩個函數分別是阻塞等待和超時等待.

94. 等待條件函數等待條件變為真, 傳遞給pthread_cond_wait的互斥量對條件進行保護, 調用者把鎖住的互斥量傳遞給函數. 函數把調用線程放到等待條件的線程列表上, 然後對互斥量解鎖, 這兩個操作是原子的. 這樣 便關閉了條件檢查和線程進入休眠狀態等待條件改變這兩個操作之間的時間通道, 這樣線程就不會錯過條件的任何變化.

96. 當pthread_cond_wait返回時, 互斥量再次被鎖住.

98. pthread_cond_wait函數的返回並不意味著條件的值一定發生了變化，必須重新檢查條件的值。

100. pthread_cond_wait函數返回時，相應的互斥鎖將被當前線程鎖定，即使是函數出錯返回。

102. 阻塞在條件變數上的線程被喚醒以後，直到pthread_cond_wait()函數返回之前條件的值都有可能發生變化。所以函數返回以後，在鎖定相應的互斥鎖之前，必須重新測試條 件值。最好的測試方法是循環調用pthread_cond_wait函數，並把滿足條件的表達式置為循環的終止條件。如：

104. pthread_mutex_lock();

106. while (condition_is_false)

108. pthread_cond_wait();

110. pthread_mutex_unlock();

112. 阻塞在同一個條件變數上的不同線程被釋放的次序是不一定的。

114. 注意：pthread_cond_wait()函數是退出點，如果在調用這個函數時，已有一個掛起的退出請求，且線程允許退出，這個線程將被終止並開始執行善後處理函數，而這時和條 件變數相關的互斥鎖仍將處在鎖定狀態。

116. pthread_cond_timedwait函數到了一定的時間，即使條件未發生也會解除阻塞。這個時間由參數abstime指定。函數返回時，相應的互斥鎖往往是鎖定的，即使是函數出錯返回。

118. 注意：pthread_cond_timedwait函數也是退出點。

120. 超時時間參數是指一天中的某個時刻。使用舉例：

122. pthread_timestruc_t to;

124. to.tv_sec = time(NULL) + TIMEOUT;

126. to.tv_nsec = 0;

128. 超時返回的錯誤碼是ETIMEDOUT。

130. 3. 通知條件:

131. #include

132. int pthread_cond_signal(pthread_cond_t *cond);

133. int pthread_cond_broadcast(pthread_cond_t *cond);

135. 成功則返回0, 出錯則返回錯誤編號.

137. 這兩個函數用於通知線程條件已經滿足. 調用這兩個函數, 也稱向線程或條件發送信號. 必須注意, 一定要在改變條件狀態以後再給線程發送信號.
     

J. linux下互斥鎖mutex，貌似鎖不上呢

多線程的效果就是同一時間各個線程都在執行。
加鎖不是給線程上鎖。

pthread_mutex_lock(&qlock);表示嘗試去把qlock上鎖，它會先判斷qlock是否已經上鎖，如果已經上鎖這個線程就會停在這一步直到其他線程把鎖解開。它才繼續運行。
所以代碼中要麼是線程1先執行完後執行線程2，要麼就是線程2先執行，再執行線程1.而線程3一開始就執行了。
互斥量mutex是用來給多線程之間的貢獻資源上鎖的。也就是同一個時間只允許一個線程去訪問該資源（資源：比如對文件的寫操作）。
現在來回答樓主的問題：
不是只要在pthread_mutex_lock(&qlock)與pthread_mutex_unlock(&qlock)之間的代碼執行，其他的都不能介入嗎？
其他的都不能介入，不是整個進程只運行這一個線程，其他線程都停住了。
「不能介入「這個動作需要程序員自己設計來保證：好比前面提到的文件讀寫操作。為了防止多個線程同時對文件進行寫入操作，這就需要把資源上鎖了。
如果只有線程1加鎖，那是不是這個鎖就沒有意義了呢？
這個理解可以有