linux下程序、以及程序間的通訊機制
2.1程序基本概念
程序是Linux事務管理的基本單元，所有的程序均擁有自己獨立的處理環境和系統資源。程序的環境由當前系統狀態及其父程序資訊決定和組成。系統的第一個程序init由核心產生，以後所有的程序都是通過fork函式/vfork()建立。系統在核心標頭檔案中定義了程序控制塊PCB結構體struct task_struct來管理每個程序的資源。
程序資源由兩部分組成：核心空間程序資源和使用者空間程序資源。
核心空間程序資源：即為PCB相關的資訊，包括程序控制塊本身、開啟的檔案表項、當前目錄、當前終端資訊、執行緒基本資訊、可訪問記憶體地址空間、PID、PPID、UID、EUID等。核心通過PCB訪問到該程序所有的資源，這些資源只能通過系統呼叫才能訪問。
程序使用者資源：實質就是程序的程式碼段、資料段、堆、棧、以及可以共享訪問的庫的記憶體空間。
2.2程序的管理
建立程序：fork() 建立成功後，將為子程序申請PCB和使用者記憶體空間、子程序會複製父程序的幾乎所有資訊，使用者空間的所有資訊、PCB的絕大多數資訊。
vfork() :建立程序。和fork（）的區別在於，vfork是共享父程序的程式碼以及資料段的。
回收程序使用者資源：
退出程序：exit(); _exit();
等待子程序結束：wait();
2.3在程序中執行新程式碼
希望在子程序中執行新程式碼，則可以呼叫execX()系列函式。當呼叫execX系列函式，該程序的使用者空間資源完全由新程式替代。核心基本不修改。
可以執行新程式碼，這也是建立子程序的重要原因。
2.4孤兒程序和僵死程序、
孤兒程序：父程序先退出二導致一個子程序被init程序收養的程序。
僵死程序：程序已退出，但它的父程序還沒有回收核心資源的程序。即該程序的核心空間的PCB沒有釋放。
2.5守候程序
是一種在後臺執行的特殊程序，它脫離終端，從而可避免程序被任何終端所產生的訊號所打斷。
建立守候程序要遵循一定的步驟。
2.6程序間通訊（IPC）介紹
程序間通訊（IPC）是指在不同程序之間傳播或交換資訊。
IPC的方式通常有管道（包括無名管道和命名管道）、訊息佇列、訊號量、共享儲存、Socket、Streams等。其中Socket和Streams支援不同主機上的兩個程序IPC。
2.6.1、無名管道pipe
管道，通常指無名管道，是 UNIX 系統IPC最古老的形式。
1、特點：
1. 它是半雙工的（即資料只能在一個方向上流動），具有固定的讀端和寫端。
2. 它只能用於具有親緣關係的程序之間的通訊（也是父子程序或者兄弟程序之間）。
3. 它可以看成是一種特殊的檔案，對於它的讀寫也可以使用普通的read、write等函式。但是它不是普通的檔案，並不屬於其他任何檔案系統，並且只存在於記憶體中。
2、原型：
1 #include <unistd.h>
2 int pipe(int fd[2]); // 返回值：若成功返回0，失敗返回-1
當一個管道建立時，它會建立兩個檔案描述符：fd[0]為讀而開啟，fd[1]為寫而開啟。如下圖：
要關閉管道只需將這兩個檔案描述符關閉即可。
3、例子
單個程序中的管道幾乎沒有任何用處。所以，通常呼叫 pipe 的程序接著呼叫 fork，這樣就建立了父程序與子程序之間的 IPC 通道。如下圖所示：
若要資料流從父程序流向子程序，則關閉父程序的讀端（fd[0]）與子程序的寫端（fd[1]）；反之，則可以使資料流從子程序流向父程序。
#include<stdio.h>
#include<unistd.h>
int main()
{
int fd[2]; // 兩個檔案描述符
pid_t pid;
char buff[20];
if(pipe(fd) < 0) // 建立管道
printf("Create Pipe Error!\n");
if((pid = fork()) < 0) // 建立子程序
printf("Fork Error!\n");
else if(pid > 0) // 父程序
{
close(fd[0]); // 關閉讀端
write(fd[1], "hello world\n", 12);
}
else
{
close(fd[1]); // 關閉寫端
read(fd[0], buff, 20);
printf("%s", buff);
}
return 0;
}
2.6.2、有名管道FIFO
FIFO，也稱為命名管道，它是一種檔案型別。
1、特點
1. FIFO可以在無關的程序之間交換資料，與無名管道不同。
2. FIFO有路徑名與之相關聯，它以一種特殊裝置檔案形式存在於檔案系統中。
2、原型
1 #include <sys/stat.h>
2 // 返回值：成功返回0，出錯返回-1
3 int mkfifo(const char *pathname, mode_t mode);
其中的 mode 引數與open函式中的 mode 相同。一旦建立了一個 FIFO，就可以用一般的檔案I/O函式操作它。
當 open 一個FIFO時，是否設定非阻塞標誌（O_NONBLOCK）的區別：
· 若沒有指定O_NONBLOCK（預設），只讀 open 要阻塞到某個其他程序為寫而開啟此 FIFO。類似的，只寫 open 要阻塞到某個其他程序為讀而開啟它。
· 若指定了O_NONBLOCK，則只讀 open 立即返回。而只寫 open 將出錯返回 -1 如果沒有程序已經為讀而開啟該 FIFO，其errno置ENXIO。
3、例子
FIFO的通訊方式類似於在程序中使用檔案來傳輸資料，只不過FIFO型別檔案同時具有管道的特性。在資料讀出時，FIFO管道中同時清除資料，並且“先進先出”。下面的例子演示了使用 FIFO 進行IPC 的過程：
write_fifo.c
#include<stdio.h>
#include<stdlib.h> // exit
#include<fcntl.h> // O_WRONLY
#include<sys/stat.h>
#include<time.h> // time
int main()
{
int fd;
int n, i;
char buf[1024];
time_t tp;
printf("I am %d process.\n", getpid()); // 說明程序ID
if((fd = open("fifo1", O_WRONLY)) < 0) // 以寫開啟一個FIFO
{
perror("Open FIFO Failed");
exit(1);
}
for(i=0; i<10; ++i)
{
time(&tp); // 取系統當前時間
n=sprintf(buf,"Process %d's time is %s",getpid(),ctime(&tp));
printf("Send message: %s", buf); // 列印
if(write(fd, buf, n+1) < 0) // 寫入到FIFO中
{
perror("Write FIFO Failed");
close(fd);
exit(1);
}
sleep(1); // 休眠1秒
}
close(fd); // 關閉FIFO檔案
return 0;
}
read_fifo.c
#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<fcntl.h>
#include<sys/stat.h>
int main()
{
int fd;
int len;
char buf[1024];
if(mkfifo("fifo1", 0666) < 0 && errno!=EEXIST) // 建立FIFO管道
perror("Create FIFO Failed");
if((fd = open("fifo1", O_RDONLY)) < 0) // 以讀開啟FIFO
{
perror("Open FIFO Failed");
exit(1);
}
while((len = read(fd, buf, 1024)) > 0) // 讀取FIFO管道
printf("Read message: %s", buf);
close(fd); // 關閉FIFO檔案
return 0;
}
上述例子可以擴充套件成 客戶程序—伺服器程序 通訊的例項，write_fifo的作用類似於客戶端，可以開啟多個客戶端向一個伺服器傳送請求資訊，read_fifo類似於伺服器，它適時監控著FIFO的讀端，當有資料時，讀出並進行處理，但是有一個關鍵的問題是，每一個客戶端必須預先知道伺服器提供的FIFO介面，下圖顯示了這種安排：
2.6.3訊息佇列
是訊息的連結表，存放在核心中。一個訊息佇列由一個識別符號（即佇列ID）來標識。
1、特點
1. 訊息佇列是面向記錄的，其中的訊息具有特定的格式以及特定的優先順序。
2. 訊息佇列獨立於傳送與接收程序。程序終止時，訊息佇列及其內容並不會被刪除。
3. 訊息佇列可以實現訊息的隨機查詢,訊息不一定要以先進先出的次序讀取,也可以按訊息的型別讀取。
2、原型
1 #include <sys/msg.h>
2 // 建立或開啟訊息佇列：成功返回佇列ID，失敗返回-1
3 int msgget(key_t key, int flag);
4 // 新增訊息：成功返回0，失敗返回-1
5 int msgsnd(int msqid, const void *ptr, size_t size, int flag);
6 // 讀取訊息：成功返回訊息資料的長度，失敗返回-1
7 int msgrcv(int msqid, void *ptr, size_t size, long type,int flag);
8 // 控制訊息佇列：成功返回0，失敗返回-1
9 int msgctl(int msqid, int cmd, struct msqid_ds *buf);
在以下兩種情況下，msgget將建立一個新的訊息佇列：
· 如果沒有與鍵值key相對應的訊息佇列，並且flag中包含了IPC_CREAT標誌位。
· key引數為IPC_PRIVATE。
函式msgrcv在讀取訊息佇列時，type引數有下面幾種情況：
· type == 0，返回佇列中的第一個訊息；
· type > 0，返回佇列中訊息型別為type 的第一個訊息；
· type < 0，返回佇列中訊息型別值小於或等於 type 絕對值的訊息，如果有多個，則取型別值最小的訊息。
可以看出，type值非 0 時用於以非先進先出次序讀訊息。也可以把 type 看做優先順序的權值。（其他的引數解釋，請自行Google之）
3、例子
下面寫了一個簡單的使用訊息佇列進行IPC的例子，服務端程式一直在等待特定型別的訊息，當收到該型別的訊息以後，傳送另一種特定型別的訊息作為反饋，客戶端讀取該反饋並打印出來。
msg_server.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>
// 用於建立一個唯一的key
#define MSG_FILE "/etc/passwd"
// 訊息結構
struct msg_form {
long mtype;
char mtext[256];
};
int main()
{
int msqid;
key_t key;
struct msg_form msg;
// 獲取key值
if((key = ftok(MSG_FILE,'z')) < 0)
{
perror("ftok error");
exit(1);
}
// 列印key值
printf("Message Queue - Server key is: %d.\n", key);
// 建立訊息佇列
if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
{
perror("msgget error");
exit(1);
}
// 列印訊息佇列ID及程序ID
printf("My msqid is: %d.\n", msqid);
printf("My pid is: %d.\n", getpid());
// 迴圈讀取訊息
for(;;)
{
msgrcv(msqid, &msg, 256, 888, 0);// 返回型別為888的第一個訊息
printf("Server: receive msg.mtext is: %s.\n", msg.mtext);
printf("Server: receive msg.mtype is: %d.\n", msg.mtype);
msg.mtype = 999; // 客戶端接收的訊息型別
sprintf(msg.mtext, "hello, I'm server %d", getpid());
msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
}
return 0;
}
msg_client.c
#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>
// 用於建立一個唯一的key
#define MSG_FILE "/etc/passwd"
// 訊息結構
struct msg_form {
long mtype;
char mtext[256];
};
int main()
{
int msqid;
key_t key;
struct msg_form msg;
// 獲取key值
if ((key = ftok(MSG_FILE, 'z')) < 0)
{
perror("ftok error");
exit(1);
}
// 列印key值
printf("Message Queue - Client key is: %d.\n", key);
// 開啟訊息佇列
if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
{
perror("msgget error");
exit(1);
}
// 列印訊息佇列ID及程序ID
printf("My msqid is: %d.\n", msqid);
printf("My pid is: %d.\n", getpid());
// 新增訊息，型別為888
msg.mtype = 888;
sprintf(msg.mtext, "hello, I'm client %d", getpid());
msgsnd(msqid, &msg, sizeof(msg.mtext), 0);
// 讀取型別為777的訊息
msgrcv(msqid, &msg, 256, 999, 0);
printf("Client: receive msg.mtext is: %s.\n", msg.mtext);
printf("Client: receive msg.mtype is: %d.\n", msg.mtype);
return 0;
}
2.6.4訊號量
訊號量（semaphore）與已經介紹過的 IPC 結構不同，它是一個計數器。訊號量用於實現程序間的互斥與同步，而不是用於儲存程序間通訊資料。
1、特點
1. 訊號量用於程序間同步，若要在程序間傳遞資料需要結合共享記憶體。
2. 訊號量基於作業系統的 PV 操作，程式對訊號量的操作都是原子操作。
3. 每次對訊號量的 PV 操作不僅限於對訊號量值加 1 或減 1，而且可以加減任意正整數。
4. 支援訊號量組。
2、原型
最簡單的訊號量是隻能取 0 和 1 的變數，這也是訊號量最常見的一種形式，叫做二值訊號量（BinarySemaphore）。而可以取多個正整數的訊號量被稱為通用訊號量。
Linux 下的訊號量函式都是在通用的訊號量陣列上進行操作，而不是在一個單一的二值訊號量上進行操作。
1 #include <sys/sem.h>
2 // 建立或獲取一個訊號量組：若成功返回訊號量集ID，失敗返回-1
3 int semget(key_t key, int num_sems, int sem_flags);
4 // 對訊號量組進行操作，改變訊號量的值：成功返回0，失敗返回-1
5 int semop(int semid, struct sembuf semoparray[], size_t numops);
6 // 控制訊號量的相關資訊
7 int semctl(int semid, int sem_num, int cmd, ...);
當semget建立新的訊號量集合時，必須指定集合中訊號量的個數（即num_sems），通常為1； 如果是引用一個現有的集合，則將num_sems指定為 0 。
在semop函式中，sembuf結構的定義如下：
1 struct sembuf
2 {
3 short sem_num; // 訊號量組中對應的序號，0～sem_nums-1
4 short sem_op; // 訊號量值在一次操作中的改變數
5 short sem_flg; // IPC_NOWAIT, SEM_UNDO
6 }
其中 sem_op 是一次操作中的訊號量的改變數：
· 若sem_op > 0，表示程序釋放相應的資源數，將 sem_op 的值加到訊號量的值上。如果有程序正在休眠等待此訊號量，則換行它們。
· 若sem_op < 0，請求 sem_op 的絕對值的資源。
o 如果相應的資源數可以滿足請求，則將該訊號量的值減去sem_op的絕對值，函式成功返回。
o 當相應的資源數不能滿足請求時，這個操作與sem_flg有關。
§ sem_flg 指定IPC_NOWAIT，則semop函數出錯返回EAGAIN。
§ sem_flg 沒有指定IPC_NOWAIT，則將該訊號量的semncnt值加1，然後程序掛起直到下述情況發生：
1. 當相應的資源數可以滿足請求，此訊號量的semncnt值減1，該訊號量的值減去sem_op的絕對值。成功返回；
2. 此訊號量被刪除，函式smeop出錯返回EIDRM；
3. 程序捕捉到訊號，並從訊號處理函式返回，此情況下將此訊號量的semncnt值減1，函式semop出錯返回EINTR
· 若sem_op == 0，程序阻塞直到訊號量的相應值為0：
o 當訊號量已經為0，函式立即返回。
o 如果訊號量的值不為0，則依據sem_flg決定函式動作：
§ sem_flg指定IPC_NOWAIT，則出錯返回EAGAIN。
§ sem_flg沒有指定IPC_NOWAIT，則將該訊號量的semncnt值加1，然後程序掛起直到下述情況發生：
1. 訊號量值為0，將訊號量的semzcnt的值減1，函式semop成功返回；
2. 此訊號量被刪除，函式smeop出錯返回EIDRM；
3. 程序捕捉到訊號，並從訊號處理函式返回，在此情況將此訊號量的semncnt值減1，函式semop出錯返回EINTR
在semctl函式中的命令有多種，這裡就說兩個常用的：
· SETVAL：用於初始化訊號量為一個已知的值。所需要的值作為聯合semun的val成員來傳遞。在訊號量第一次使用之前需要設定訊號量。
· IPC_RMID：刪除一個訊號量集合。如果不刪除訊號量，它將繼續在系統中存在，即使程式已經退出，它可能在你下次執行此程式時引發問題，而且訊號量是一種有限的資源。
3、例子
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<sys/sem.h>
4
5 // 聯合體，用於semctl初始化
6 union semun
7 {
8 int val; /*for SETVAL*/
9 struct semid_ds *buf;
10 unsigned short *array;
11 };
12
13 // 初始化訊號量
14 int init_sem(int sem_id, int value)
15 {
16 union semun tmp;
17 tmp.val = value;
18 if(semctl(sem_id, 0, SETVAL, tmp) == -1)
19 {
20 perror("Init Semaphore Error");
21 return -1;
22 }
23 return 0;
24 }
25
26 // P操作:
27 // 若訊號量值為1，獲取資源並將訊號量值-1
28 // 若信號量值為0，程序掛起等待
29 int sem_p(int sem_id)
30 {
31 struct sembuf sbuf;
32 sbuf.sem_num = 0; /*序號*/
33 sbuf.sem_op = -1; /*P操作*/
34 sbuf.sem_flg = SEM_UNDO;
35
36 if(semop(sem_id, &sbuf, 1) == -1)
37 {
38 perror("P operation Error");
39 return -1;
40 }
41 return 0;
42 }
43
44 // V操作：
45 // 釋放資源並將訊號量值+1
46 // 如果有程序正在掛起等待，則喚醒它們
47 int sem_v(int sem_id)
48 {
49 struct sembuf sbuf;
50 sbuf.sem_num = 0; /*序號*/
51 sbuf.sem_op = 1; /*V操作*/
52 sbuf.sem_flg = SEM_UNDO;
53
54 if(semop(sem_id, &sbuf, 1) == -1)
55 {
56 perror("V operation Error");
57 return -1;
58 }
59 return 0;
60 }
61
62 // 刪除訊號量集
63 int del_sem(int sem_id)
64 {
65 union semun tmp;
66 if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
67 {
68 perror("Delete Semaphore Error");
69 return -1;
70 }
71 return 0;
72 }
73
74
75 int main()
76 {
77 int sem_id; // 訊號量集ID
78 key_t key;
79 pid_t pid;
80
81 // 獲取key值
82 if((key = ftok(".", 'z')) < 0)
83 {
84 perror("ftok error");
85 exit(1);
86 }
87
88 // 建立訊號量集，其中只有一個訊號量
89 if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
90 {
91 perror("semget error");
92 exit(1);
93 }
94
95 // 初始化：初值設為0資源被佔用
96 init_sem(sem_id, 0);
97
98 if((pid = fork()) == -1)
99 perror("Fork Error");
100 else if(pid == 0) /*子程序*/
101 {
102 sleep(2);
103 printf("Process child: pid=%d\n", getpid());
104 sem_v(sem_id); /*釋放資源*/
105 }
106 else /*父程序*/
107 {
108 sem_p(sem_id); /*等待資源*/
109 printf("Process father: pid=%d\n", getpid());
110 sem_v(sem_id); /*釋放資源*/
111 del_sem(sem_id); /*刪除訊號量集*/
112 }
113 return 0;
114 }
上面的例子如果不加訊號量，則父程序會先執行完畢。這裡加了訊號量讓父程序等待子程序執行完以後再執行。
2.6.5、共享記憶體
共享記憶體（Shared Memory），指兩個或多個程序共享一個給定的儲存區。
1、特點
1. 共享記憶體是最快的一種 IPC，因為程序是直接對記憶體進行存取。
2. 因為多個程序可以同時操作，所以需要進行同步。
3. 訊號量+共享記憶體通常結合在一起使用，訊號量用來同步對共享記憶體的訪問。
2、原型
1 #include <sys/shm.h>
2 // 建立或獲取一個共享記憶體：成功返回共享記憶體ID，失敗返回-1
3 int shmget(key_t key, size_t size, int flag);
4 // 連線共享記憶體到當前程序的地址空間：成功返回指向共享記憶體的指標，失敗返回-1
5 void *shmat(int shm_id, const void *addr, int flag);
6 // 斷開與共享記憶體的連線：成功返回0，失敗返回-1
7 int shmdt(void *addr);
8 // 控制共享記憶體的相關資訊：成功返回0，失敗返回-1
9 int shmctl(int shm_id, int cmd, struct shmid_ds *buf);
當用shmget函式建立一段共享記憶體時，必須指定其 size；而如果引用一個已存在的共享記憶體，則將 size 指定為0 。
當一段共享記憶體被建立以後，它並不能被任何程序訪問。必須使用shmat函式連線該共享記憶體到當前程序的地址空間，連線成功後把共享記憶體區物件對映到呼叫程序的地址空間，隨後可像本地空間一樣訪問。
shmdt函式是用來斷開shmat建立的連線的。注意，這並不是從系統中刪除該共享記憶體，只是當前程序不能再訪問該共享記憶體而已。
shmctl函式可以對共享記憶體執行多種操作，根據引數 cmd 執行相應的操作。常用的是IPC_RMID（從系統中刪除該共享記憶體）。
3、例子
下面這個例子，使用了【共享記憶體+訊號量+訊息佇列】的組合來實現伺服器程序與客戶程序間的通訊。
· 共享記憶體用來傳遞資料；
· 訊號量用來同步；
· 訊息佇列用來在客戶端修改了共享記憶體後通知伺服器讀取。
server.c
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<sys/shm.h> // shared memory
4 #include<sys/sem.h> // semaphore
5 #include<sys/msg.h> // message queue
6 #include<string.h> // memcpy
7
8 // 訊息佇列結構
9 struct msg_form {
10 long mtype;
11 char mtext;
12 };
13
14 // 聯合體，用於semctl初始化
15 union semun
16 {
17 int val; /*for SETVAL*/
18 struct semid_ds *buf;
19 unsigned short *array;
20 };
21
22 // 初始化訊號量
23 int init_sem(int sem_id, int value)
24 {
25 union semun tmp;
26 tmp.val = value;
27 if(semctl(sem_id, 0, SETVAL, tmp) == -1)
28 {
29 perror("Init Semaphore Error");
30 return -1;
31 }
32 return 0;
33 }
34
35 // P操作:
36 // 若訊號量值為1，獲取資源並將訊號量值-1
37 // 若訊號量值為0，程序掛起等待
38 int sem_p(int sem_id)
39 {
40 struct sembuf sbuf;
41 sbuf.sem_num = 0; /*序號*/
42 sbuf.sem_op = -1; /*P操作*/
43 sbuf.sem_flg = SEM_UNDO;
44
45 if(semop(sem_id, &sbuf, 1) == -1)
46 {
47 perror("P operation Error");
48 return -1;
49 }
50 return 0;
51 }
52
53 // V操作：
54 // 釋放資源並將訊號量值+1
55 // 如果有程序正在掛起等待，則喚醒它們
56 int sem_v(int sem_id)
57 {
58 struct sembuf sbuf;
59 sbuf.sem_num = 0; /*序號*/
60 sbuf.sem_op = 1; /*V操作*/
61 sbuf.sem_flg = SEM_UNDO;
62
63 if(semop(sem_id, &sbuf, 1) == -1)
64 {
65 perror("V operation Error");
66 return -1;
67 }
68 return 0;
69 }
70
71 // 刪除訊號量集
72 int del_sem(int sem_id)
73 {
74 union semun tmp;
75 if(semctl(sem_id, 0, IPC_RMID, tmp) == -1)
76 {
77 perror("Delete Semaphore Error");
78 return -1;
79 }
80 return 0;
81 }
82
83 // 建立一個訊號量集
84 int creat_sem(key_t key)
85 {
86 int sem_id;
87 if((sem_id = semget(key, 1, IPC_CREAT|0666)) == -1)
88 {
89 perror("semget error");
90 exit(-1);
91 }
92 init_sem(sem_id, 1); /*初值設為1資源未佔用*/
93 return sem_id;
94 }
95
96
97 int main()
98 {
99 key_t key;
100 int shmid, semid, msqid;
101 char *shm;
102 char data[] = "this is server";
103 struct shmid_ds buf1; /*用於刪除共享記憶體*/
104 struct msqid_ds buf2; /*用於刪除訊息佇列*/
105 struct msg_form msg; /*訊息佇列用於通知對方更新了共享記憶體*/
106
107 // 獲取key值
108 if((key = ftok(".", 'z')) < 0)
109 {
110 perror("ftok error");
111 exit(1);
112 }
113
114 // 建立共享記憶體
115 if((shmid = shmget(key, 1024, IPC_CREAT|0666)) == -1)
116 {
117 perror("Create Shared Memory Error");
118 exit(1);
119 }
120
121 // 連線共享記憶體
122 shm = (char*)shmat(shmid, 0, 0);
123 if((int)shm == -1)
124 {
125 perror("Attach Shared Memory Error");
126 exit(1);
127 }
128
129
130 // 建立訊息佇列
131 if ((msqid = msgget(key, IPC_CREAT|0777)) == -1)
132 {
133 perror("msgget error");
134 exit(1);
135 }
136
137 // 建立訊號量
138 semid = creat_sem(key);
139
140 // 讀資料
141 while(1)
142 {
143 msgrcv(msqid, &msg, 1, 888, 0); /*讀取型別為888的訊息*/
144 if(msg.mtext == 'q') /*quit - 跳出迴圈*/
145 break;
146 if(msg.mtext == 'r') /*read - 讀共享記憶體*/
147 {
148 sem_p(semid);
149 printf("%s\n",shm);
150 sem_v(semid);
151 }
152 }
153
154 // 斷開連線
155 shmdt(shm);
156
157 /*刪除共享記憶體、訊息佇列、訊號量*/
158 shmctl(shmid, IPC_RMID, &buf1);
159 msgctl(msqid, IPC_RMID, &buf2);
160 del_sem(semid);
161 return 0;
162 }
client.c
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<sys/shm.h> // shared memory
4 #include<sys/sem.h> // semaphore
5 #include<sys/msg.h> // message queue
6 #include<string.h> // memcpy
7
8 // 訊息佇列結構
9 struct msg_form {
10 long mtype;
11 char mtext;
12 };
13
14 // 聯合體，用於semctl初始化
15 union semun
16 {
17 int val; /*for SETVAL*/
18 struct semid_ds *buf;
19 unsigned short *array;
20 };
21
22 // P操作:
23 // 若訊號量值為1，獲取資源並將訊號量值-1
24 // 若訊號量值為0，程序掛起等待
25 int sem_p(int sem_id)
26 {
27 struct sembuf sbuf;
28 sbuf.sem_num = 0; /*序號*/
29 sbuf.sem_op = -1; /*P操作*/
30 sbuf.sem_flg = SEM_UNDO;
31
32 if(semop(sem_id, &sbuf, 1) == -1)
33 {
34 perror("P operation Error");
35 return -1;
36 }
37 return 0;
38 }
39
40 // V操作：
41 // 釋放資源並將訊號量值+1
42 // 如果有程序正在掛起等待，則喚醒它們
43 int sem_v(int sem_id)
44 {
45 struct sembuf sbuf;
46 sbuf.sem_num = 0; /*序號*/
47 sbuf.sem_op = 1; /*V操作*/
48 sbuf.sem_flg = SEM_UNDO;
49
50 if(semop(sem_id, &sbuf, 1) == -1)
51 {
52 perror("V operation Error");
53 &nb