在前面，我們學習了傳統的程序間通訊方式——無名管道（pipe）、有名管道（fifo）和訊號（signal）。

        下面我們來學習 System V  IPC 物件：

1、共享記憶體（share memory）；

2、訊號燈（semaohore）；

3、訊息佇列（message queue）；

IPC物件是活動在核心級別的一種程序間通訊的工具。存在的IPC物件通過它的識別符號來引用和訪問，這個識別符號是一個非負整數，它唯一的標識了一個IPC物件，這個IPC物件可以是訊息佇列或訊號量或共享儲存器中的任意一種型別。

     Linux系統中識別符號被宣告成整數，所以可能存在的最大識別符號為65535。當時對於IPC物件，其識別符號（id）

     IPC的識別符號只解決了內部訪問一個IPC物件的問題，如何讓多個程序都訪問某一個特定的IPC物件還需要一個外部鍵（key），一個IPC物件都與一個鍵相關聯。這樣就解決了多程序在一個IPC物件上匯合的問題。IPC物件時需要指定一個鍵值，型別為key_t，在<sys/types.h>中定義為一個長整型。鍵值到識別符號的轉換是由系統核心來維護的，這裡呼叫IPC物件的建立函式（semget msgget shmget ）

      從上圖中我們可以看到得到這個鍵值 key 有兩種方法：

1）通用方法：呼叫ftok()函式
       函式ftok可以使用兩個引數生成一個鍵值，函式原型如下：

#include <sys/ipc.h>
key_t ftok( const char *path, int id );

       函式中引數path是一個檔名。函式中進行的操作是，取該檔案的stat結構的st_dev成員和st_ino成員的部分值，然後與引數ID的第八位結合起來生成一個鍵值。由於只是使用st_dew和st_ino的部分值，所以會丟失資訊，不排除兩個不同檔案使用同一個ID，得到同樣鍵值的情況。
系統為每一個IPC物件儲存一個ipc_perm結構體，該結構說明了IPC物件的許可權和所有者，每一個版本的核心各有不用的ipc_perm結構成員。

檔案<sys/ipc.h> 中對其定義：

struct ipc_perm 
{
	ey_t key;
	id_t uid;
	id_t gid;
	id_t cuid;
	id_t cgid;
	nsigned short mode;
	nsigned short seq;
};

2）父子程序之間：

      Key 為IPC_PRIVATE，父子程序之間key值為IPC_PRIVATE。

      當有了一個IPC物件的鍵值，如何讓多個程序知道這個鍵，可以有多種實現的辦法：

1) 、使用檔案來做中間的通道，建立IPC物件程序，使用鍵IPC_PRIVATE成功建立IPC物件之後，將返回的識別符號儲存在一個檔案中。其他程序通過讀取這個識別符號來引用IPC物件通訊。

2)、定義一個多個程序都認可的鍵，每個程序使用這個鍵來引用IPC物件，值得注意的是，建立IPC物件的程序中，建立IPC物件時如果該鍵值已經與一個IPC物件結合，則應該刪除該IPC物件，再建立一個新的IPC物件。

3)、多程序通訊中，對於指定鍵引用一個IPC物件而言，可能不具有拓展性，並且在該鍵值已經被一個IPC物件結合的情況下。所以必須刪除這個存在物件之後再建立一個新的。這有可能影響到其他正在使用這個物件的程序。函式ftok可以在一定程度上解決這個問題。

但IPC物件存在一些問題，主要集中在以下幾點：

1）、過於繁雜的程式設計介面，比起使用其他通訊方式，IPC所要求的程式碼量要明顯增多。

2）、IPC不使用通用的檔案系統，這也是飽受指責的原因。所以不能使用標準I/O操作函式來讀寫IPC物件。為此不得不新增加一些函式來支援必要的一些操作（例如msgget msgrev msgctl等）並且對於不同型別的IPC物件都有一系列特定的操作函式。由於IPC不使用檔案描述符，所以不能使用多路I/O監控函式select及poll函式來操作IPC物件。

3）、缺少的資源回收機制。由於IPC物件在使用過程中並不儲存引用計數，所以當出現一個程序建立了IPC物件然後退出時，則這個物件只有在出現後面幾種情況才會被釋放或者刪除，即由某一個程序讀出訊息，或者IPC的所有者或超級使用者刪除了這個物件。這也是IPC相對於管道或FIFO所欠缺的資源回收機制。

下面是檔案物件和IPC物件的對比

一、共享記憶體

       共享記憶體可以說是Linux 下最快速、最有效的程序間通訊方式。兩個不同程序A 、B 共享記憶體的意思是，同一塊實體記憶體被對映到程序A 、B 各自的程序地址空間，程序A 可以即時看到程序B 對共享記憶體中資料的更新；反之，程序B 也可以即時看到程序A對共享記憶體中資料的更新。

       這裡簡單說下對映的概念：

       Linux系統會為每個程序分配 4GB 的虛擬地址空間，一定情況下，需要將虛擬記憶體轉換成實體記憶體，這就需要記憶體對映。為什麼我們需要使用虛擬地址呢？最主要的原因是不同PC的實體記憶體會不一樣，如果直接使用實體地址，會造成程式的移植性很差，另外虛擬地址訪問記憶體有以下優勢：

1、程式可以使用一系列相鄰的虛擬地址來訪問實體記憶體中不相鄰的大記憶體緩衝區。

2、程式可以使用一系列虛擬地址來訪問大於可用實體記憶體的記憶體緩衝區。當實體記憶體的供應量變小時，記憶體管理器會將實體記憶體頁（通常大小為 4 KB）儲存到磁碟檔案。資料或內碼表會根據需要在實體記憶體與磁碟之間移動。

3、不同程序使用的虛擬地址彼此隔離。一個程序中的程式碼無法更改正在由另一程序或作業系統使用的實體記憶體。

      程序可用的虛擬地址範圍稱為該程序的“虛擬地址空間”。每個使用者模式程序都有其各自的專用虛擬地址空間。對於 32 位程序，虛擬地址空間通常為 4 GB，範圍從 0x00000000 至 0xFFFFFFFF。

1、共享記憶體的概念

      共享記憶體從字面意義解釋就是多個程序可以把一段記憶體對映到自己的程序空間，以此來實現資料的共享及傳輸，這也是所有程序間通訊方式最快的一種，共享記憶體是存在於核心級別的一種資源。

      在Shell 中可以使用ipcs 命令檢視當前系統IPC中的狀態，在檔案系統中/proc目錄下有對其描述的相應檔案

 ipcs  -m ，其中 -m 是 memory 的意思 。

      在系統核心為一個程序分配記憶體地址時，通過分頁機制可以讓一個程序的實體地址不連續，同時也可以讓一段記憶體同時分配給不同的程序。共享記憶體機制就是通過該原理實現的，共享記憶體機制只是提供資料的傳送，如何控制伺服器端和客戶端的讀寫操作互斥，這就需要一些其他的輔助工具，例如訊號量。

      採用共享記憶體通訊的一個顯而易見的好處就是效率高，因為程序可以直接讀寫記憶體，而不需要任何資料的拷貝。對於像管道和訊息佇列等通訊方式，則需要在核心和使用者控制元件進行四次資料的拷貝，而共享記憶體只拷貝兩次資料：一次從輸入檔案到共享區，另一次從共享記憶體區到輸出檔案。實際上，程序之間在共享記憶體時，並不總是讀寫少量資料後就解除對映，有新的通訊時，再重新建立共享記憶體區域。而是保持共享區域，知道通訊完畢為止，這樣，資料內同一直儲存在共享記憶體中，並沒有寫回檔案。共享記憶體中的內容往往是在接觸對映時才寫回檔案的。因此，採用共享記憶體的通訊方式效率是最高的。

     共享記憶體最大不足之處在意，由於多個程序對同一塊記憶體區域具有訪問的許可權，各個程序之間的同步問題顯得尤為重要。必須控制同一時刻只有一個程序對共享記憶體區域寫入資料，否則會造成資料的混亂。同步控制問題可以由訊號量來解決；

     對於每一個共享儲存段，核心會為其維護一個shmid_ds型別的結構體，其定義在標頭檔案<sys/shm.h>中，其定義如下：

struct shmid_ds
{
	struct ipc_perm shm_perm   //Operation permission structure.
	size_t shm_segsz  //Size of segment in bytes.
	pid_t  shm_lpid   //Process ID of last shared memory operation.
	pid_t  shm_cpid   //Process ID of creator.
	shmatt_t shm_nattch //Number of current attaches.
	time_t shm_atime  //Time of last shmat              
	time_t shm_dtime  //Time of last shmdt
	time_t shm_ctime  //Time of last change by shmctl
 }

2、共享記憶體的相關操作

1）建立或開啟共享記憶體

     要使用共享記憶體，首先要建立一個共享記憶體區域，建立共享記憶體的函式呼叫如下：

        shmget函式除了可以用於建立一個新的共享記憶體外，也可以用於開啟一個已存在的共享記憶體。其中，引數key表示索要建立或開啟的共享記憶體的鍵值。size表示共享記憶體區域的大小，只在建立一個新的共享記憶體時生效。引數shmflag 表示呼叫函式的操作型別，也可用於設定共享記憶體的訪問許可權，兩者通過邏輯或表示.引數key 和 flag 決定了呼叫函式 shmget 的作用，相應的約定如下：

1）當 key  為 IPC_PRIVATE 時，建立一個新的共享記憶體，此時引數 flag 的取值無效；

2）當 key 不為 IPC_PRIVATE時，且flag 設定了IPC_CREAT 位，而沒有設定 IPC_EXCL 位，則執行操作由key取值決定。如果key 為核心中每個已存在的共享記憶體的鍵值。則執行開啟這個鍵的操作；反之，則執行建立共享記憶體的操作；

3）當 key 不為 IPC_PRIVATE時，且flag 設定了IPC_CREAT 位和 IPC_EXCL 位，則只執行建立共享記憶體的操作。引數key的取值應與核心中已存在的任何共享記憶體的鍵值都不相同，否則函式呼叫失敗，返回EEXIST錯誤，所以一般典型的呼叫程式碼首先會檢查是否返回該錯誤，如果確實返回該錯誤，那麼只要呼叫開啟共享記憶體的函式就可以了（即將flag 設定為 IPC_CREAT，而不設定IPC_EXCL）；

2）附加

    當一個共享記憶體建立或開啟後，某個程序如果要使用該共享記憶體則必須將此記憶體區附加到它的地址空間，附加操作的系統呼叫函式如下：

        引數shmid 指定要引入的共享記憶體，引數 addr 和 flag 組合說明要引入的地址值，通常將 shmaddr 設定為NULL ，shmflag為0；

3）分離

      當程序對共享記憶體段的操作完成後，應呼叫 shmdt 函式，作用是將指定的共享記憶體段從當前程序空間中脫離出去，函式原型如下：

此函式僅用於將共享記憶體區域與程序的地址空間分離，並不刪除共享記憶體本身。引數addr是呼叫 shmat 函式時的返回值。

4）共享記憶體的控制

     由於共享記憶體這一特殊的資源型別，使它不同於普通的檔案，因此，系統需要為其提供專有的操作函式，其函式原型如下：

下面是一個例項，兩個程序間實現共享記憶體進行通訊：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#define BUFFER_SIZE 2048

int main()
{
	pid_t pid;
	int shmid;
	char *shm_addr;
	char flag[] = "WROTE";
	char buffer[BUFFER_SIZE];

	if((shmid = shmget(IPC_PRIVATE,BUFFER_SIZE,0666)) < 0)
	{
		perror("shmget");
		exit(-1);
	}
	else
	{
		printf("Create shared-memory:%d\n",shmid);
	}

	system("ipcs -m");
	pid = fork();
	if(pid < 0)
	{
		perror("fork error");
		exit(-1);
	}
	else if(pid == 0)
	{
		shm_addr = shmat(shmid,0,0);
		if(shm_addr == (void *)-1)
		{
			perror("Child:shmat");
			exit(-1);
		}
		else
		{
			printf("Child:Attach shared-memory:%p \n",shm_addr);
		}

		system("ipcs -m");

		while(strncmp(shm_addr,flag,strlen(flag)))
		{
			printf("Child:wait for enable data...\n");
			sleep(5);
		}

		strcpy(buffer,shm_addr + strlen(flag));
		printf("Child:shared-memory:%s\n",buffer);

		if((shmdt(shm_addr)) < 0)
		{
			perror("shmdt");
			exit(-1);
		}
		else
		{
			printf("Child: Deattach shared-memory\n");
		}
		system("ipcs -m");

		if(shmctl(shmid,IPC_RMID,NULL) == -1)
		{
			perror("Child:shmctl(IPC_RMID)");
			exit(-1);
		}
		else
		{
			printf("Delete shmared-memory\n");
		}

		system("ipcs -m");
	}
	else
	{
		if((shm_addr = shmat(shmid,0,0)) == (void *)-1)
		{
			perror("parent:shmat");
			exit(-1);
		}
		else
		{
			printf("Parent:Attach shmared-memory:%p\n",shm_addr);
		}

		sleep(1);
		printf("\nInput some string:\n");
		fgets(buffer,BUFFER_SIZE,stdin);
		strncpy(shm_addr + strlen(flag),buffer,strlen(buffer));
		strncpy(shm_addr,flag,strlen(flag));

		if((shmdt(shm_addr)) < 0)
		{
			perror("Parent:shmdt");
			exit(-1);
		}
		else
		{
			printf("Parent : Deattach shared-memory\n");
		}

		system("ipcs -m");
		waitpid(pid,NULL,0);
		printf("Finsihed\n");
	}
	
	return 0;
}

執行結果如下：

[email protected]:~/qiang/shm$ ./shm 
Create shared-memory:196613

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          fs         700        76800      2          dest         
0x00000000 32769      fs         700        1843200    2          dest         
0x00000000 65538      fs         700        20196      2          dest         
0x00000000 98307      fs         700        17028      2          dest         
0x00000000 131076     fs         700        19800      2          dest         
0x00000000 196613     fs         666        2048       0                       

Parent:Attach shmared-memory:0xb773d000
Child:Attach shared-memory:0xb773d000 

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          fs         700        76800      2          dest         
0x00000000 32769      fs         700        1843200    2          dest         
0x00000000 65538      fs         700        20196      2          dest         
0x00000000 98307      fs         700        17028      2          dest         
0x00000000 131076     fs         700        19800      2          dest         
0x00000000 196613     fs         666        2048       2                       

Child:wait for enable data...

Input some string:
xiaoqiang
Parent : Deattach shared-memory

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          fs         700        76800      2          dest         
0x00000000 32769      fs         700        1843200    2          dest         
0x00000000 65538      fs         700        20196      2          dest         
0x00000000 98307      fs         700        17028      2          dest         
0x00000000 131076     fs         700        19800      2          dest         
0x00000000 196613     fs         666        2048       1                       

Child:shared-memory:xiaoqiang

Child: Deattach shared-memory

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          fs         700        76800      2          dest         
0x00000000 32769      fs         700        1843200    2          dest         
0x00000000 65538      fs         700        20196      2          dest         
0x00000000 98307      fs         700        17028      2          dest         
0x00000000 131076     fs         700        19800      2          dest         
0x00000000 196613     fs         666        2048       0                       

Delete shmared-memory

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x00000000 0          fs         700        76800      2          dest         
0x00000000 32769      fs         700        1843200    2          dest         
0x00000000 65538      fs         700        20196      2          dest         
0x00000000 98307      fs         700        17028      2          dest         
0x00000000 131076     fs         700        19800      2          dest         

Finsihed
[email protected]:~/qiang/shm$

通過結果，不斷的呼叫 system ，可以看到共享記憶體區的變化；

二、訊號量

       訊號燈（semaphore），也叫訊號量，它是不同程序間或一個給定程序內部不同執行緒間同步的機制。

訊號燈種類：1）posix 有名訊號燈 2）posix 基於記憶體的訊號燈（無名訊號燈） 3）System V 訊號燈 （IPC物件）；

訊號燈：

1）二值訊號燈：值為 0 或 1。與互斥鎖類似，資源可用時值為1，不可用時值為 0；

2）計數訊號燈：值在 0 到 n 之間。用來統計資源，其值代表可用資源數；

等待操作時等待訊號燈的值變為大於0，然後將其減一；而釋放操作則相反，用來喚醒等待資源的程序或者執行緒；

事實上，在訊號量的實際應用中，是不能單獨定義一個訊號量的，而只能定義一個訊號量集，其中包含一組訊號量，同一訊號量集中的訊號量使用同一個引用ID，這樣的設定是為了多個資源和同步操作的需要。每個訊號量集都有一個與之對應結構，一種記錄了訊號量集的各種資訊，該結構的定義如下：

struct semid_ds
{           
	struct ipc_perm  sem_perm  //Operation permission structure.
	unsigned short   sem_nsems //Number of semaphores in set.
	time_t           sem_otime //Last semop            
	time_t           sem_ctime //Last time changed by semctl
}

sem結構記錄一個訊號量的資訊，其定義如下：

struct sem
{          
	unsigned short  semval   //Semaphore value.
	pid_t           sempid   //Process ID of last operation.
	unsigned short  semncnt  //Number of processes waiting for semval to become greater than current value.
	unsigned short  semzcnt  //Number of processes waiting for semval to become 0.
}

下面是訊號量操作有關的函式呼叫：

函式說明：

在Linux 系統中，使用訊號量通常分為以下幾個步驟：

1）建立訊號量或獲得系統已存在的訊號量，此時需要呼叫 semget() 函式。不同程序通過使用同一個訊號鍵值來獲得同一個訊號量；

2）初始化訊號量，此時使用 senctl() 函式的 SETVAL 操作。當使用二維訊號量時，通常將訊號量初始化為1；

3）進行訊號量的PV操作，此時呼叫 semop() 函式。這一步是實現程序之間的同步和互斥的核心工作部分；

4）如果不需要訊號量，則從系統中刪除它，此時使用semctl() 函式的IPC_RMID 操作。此時需要注意，在程式中不應該出現對已經被刪除的訊號量的操作；

下面是具體說明：

1、建立或開啟訊號量集

使用函式 semget 可以建立或者獲得一個訊號量集ID，函式原型如下：

此函式可以用於建立或開啟一個訊號量集。其中，引數key 表示要建立或開啟的訊號量集對於的鍵值。引數 nsems 表示建立的訊號量集中包含的訊號量的個數，此引數只在建立一個新的訊號量集時有效。引數flag表示呼叫函式的操作型別，也可以用於設定訊號量集的訪問許可權，兩者通過邏輯或表示。呼叫函式semget 的作用由引數key和flag 決定。

     另外，當semget 成功建立一個新的訊號量集時，它相應的semid_ds結構被初始化。ipc_perm 結構中成員被設定成相應的值 ，sem_nsems設定為函式引數nsems的值，sem_otime被設定為0，sem_ctime 設定為系統當前時間。

2、對訊號量集的操作

函式semop 用以操作一個訊號量集，函式原型如下：

結構體sembuf 用來說明所要執行的操作，其定義如下：

struct sembuf
{
	unsigned short sem_num; //要操作的訊號燈的編號
	short sem_op;   //  0: 等待，知道訊號燈的值變為0
                        //  1: 釋放資源，V操作 
                        // -1: 分配資源，P操作
	short sem_flg; //0，IPC_NOWAIT,SEM_UNDO
}

3、訊號量集的控制

和共享記憶體的控制一樣，訊號量集也有自己的專屬控制函式 semctl ，函式原型如下：

引數cmd 定義函式所要進行的操作，其取值及表達的意義與引數arg 的設定有關，最後一個引數arg 是一個聯合體（union），其定義如下：

union semun {
       int              val;    /* Value for SETVAL */
       struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
       unsigned short  *array;  /* Array for GETALL, SETALL */
       struct seminfo  *__buf;  /* Buffer for IPC_INFO(Linux-specific) */
};

下面是個應用例項：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#define DELAY_TIME 3

union semun 
{
	int              val;    /* Value for SETVAL */
	struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
	unsigned short  *array;  /* Array for GETALL, SETALL */
	struct seminfo  *__buf;  /* Buffer for IPC_INFO(Linux-specific) */
};

int init_sem(int sem_id,int init_value);
int del_sem(int sem_id);
int sem_p(int sem_id);
int sem_v(int sem_id);

int init_sem(int sem_id,int init_value)
{
	union semun sem_union;
	sem_union.val = init_value;
	if(semctl(sem_id, 0, SETVAL, sem_union) == -1)
	{
		perror("Initialize semaphore");
		exit(-1);
	}

	return 0;
}

int del_sem(int sem_id)
{
	union semun sem_union;
	if(semctl(sem_id, 0, IPC_RMID, sem_union) == -1)
	{
		perror("Delete semaphore");
		return -1;
	}
}

int sem_p(int sem_id)
{
	struct sembuf sem_b;
	sem_b.sem_num = 0;
	sem_b.sem_op = -1;
	sem_b.sem_flg = SEM_UNDO;

	if(semop(sem_id,&sem_b,1) == -1)
	{
		perror("P operation");
		return -1;
	}

	return 0;
}

int sem_v(int sem_id)
{
	struct sembuf sem_b;
	sem_b.sem_num = 0;
	sem_b.sem_op = 1;
	sem_b.sem_flg = SEM_UNDO;

	if(semop(sem_id,&sem_b,1) == -1)
	{
		perror("V operation");
		return -1;
	}

	return 0;
}

int main()
{
	pid_t pid;
	int sem_id;

	sem_id = semget(ftok(".",'a'), 1, 0666|IPC_CREAT);
	init_sem(sem_id,0);

	pid = fork();
	if(pid < 0)
	{
		perror("fork fails");
		exit(-1);
	}
	else if(pid == 0)
	{
		printf("Child process will wait for some seconds...\n");
		sleep(DELAY_TIME);
		printf("The returned value is %d in the child process(PID = %d)\n",
				pid,getpid());
		sem_v(sem_id);
	}
	else
	{
		sem_p(sem_id);
		printf("The returned value is %d in the father process(PID = %d)\n",
				pid,getpid());
		sem_v(sem_id);
		del_sem(sem_id);
	}

	return 0;
}

執行結果如下：

[email protected]:~/qiang/sem$ ./sem 
Child process will wait for some seconds...
The returned value is 0 in the child process(PID = 2882)
The returned value is 2882 in the father process(PID = 2880)
[email protected]:~/qiang/sem$