linux消息隊列相互通信

1. linux編程的利用消息隊列在兩個進程間通信，怎麼寫代碼，求思路，需要建立幾個消息隊列呢

首先建議你先參考 《advanced programming in the unix environment》 一書中的第15章（Interprocess communication 進程間通信）中的第7節（message queues 消息隊回列）了解消息隊列的相關介面答函數，比如如何創建獲取消息隊列，如何收發消息。然後就很簡單了

如果你打算兩個進程依次收消息，發消息，就像打乒乓球一樣，那麼只要一個queue，A 發消息， B 收消息並處理，然後 B 發消息, A 收並處理………… 按此次序進行下去。

更靈活的方法是兩個消息隊列 (a, b)， A 進程從 隊列a收消息，向 b 發消息。 B進程從b收消息，想a發消息。

2. Linux 進程間通信方式有哪些

1、無名管道通信
無名管道(pipe)：管道是一種半雙工的通信方式，數據只能單向流動，而且只能在具有親緣關系的進程間使用，進程的親緣關系通常是指父子進程關系。
2、高級管道通信
高級管道(popen)：將另一個大虛和程序當做一個新的進程在當前程序進程中啟動，則它算是當前程序的子進程，這種方式我們稱為高級管道方式。
3、有名管道通信
有名管道(named pipe)：有名管道也是半雙工的通信方式，但是它允許無親緣關系進程間的通信。
4、消息隊列通信
消息隊列(message
queue)：消息隊列是由消息的鏈表，存放在內核中並由消息隊列標識符標識，消息隊列克服了信號傳遞信息少、管道只能承載無格式位元組流以及緩沖區大小受限等缺點。
5、信號量通信
信號量(semophore)：信號量是一個計數器，可以用來控制多個進程對共享資源的訪問，它常作為一種鎖機制，防止某進程正在訪問共享資源時，其他進程訪問該資源。因此，主要作為進程間以及同一進程內不同線程之間的同步手段。
6、信號
信號(sinal)：信號是一種比較復雜的通信方式，用於通知接收進程某個事件已經發生。
7、共享內存通信
共享內存(shared
memory)：共享內存就是映射一段能被其他進程所訪問的內存，這段共享內存由一個進程創建，但多個進程都可以訪問。共享內存是最快的IPC方式，它是針對其他進程間通信方式運行效率低而專門設計的譽纖。它往往與其他通信機制，如信號量，配合使用，來實現進程間的同步和通信。
8、套接字通信
套接字滾盯(socket)：套接字也是一種進程間通信機制，與其他通信機制不同的是，它可用於不同機器間的進程通信。

3. linux下c的兩個進程如何實現通信一個進程給另一個進程發送消息，另一個接受並顯示出來。求大神啊

linux中的進程通信分為三個部分：低級通信，管道通信和進程間通信IPC（inter process communication）。linux的低級通信主要用來傳遞進程的控制信號——文件鎖和軟中斷信號機制。linux的進程間通信IPC有三個部分——①信號量，②共享內存和③消息隊列。以下是我編寫的linux進程通信的C語言實現代碼。操作系統為redhat9.0，編輯器為vi，編譯器採用gcc。下面所有實現代碼均已經通過測試，運行無誤。

一.低級通信--信號通信

signal.c

#include <signal.h>
#include <stdio.h>
#include <unistd.h>

/*捕捉到信號sig之後，執行預先預定的動作函數*/
void sig_alarm(int sig)
{
printf("---the signal received is %d. /n", sig);
signal(SIGINT, SIG_DFL); //SIGINT終端中斷信號，SIG_DFL：恢復默認行為，SIN_IGN：忽略信號
}

int main()
{
signal(SIGINT, sig_alarm);//捕捉終端中斷信號
while(1)
{
printf("waiting here!/n");
sleep(1);
}
return 0;
}

二.管道通信

pipe.c

#include <stdio.h>
#define BUFFER_SIZE 30

int main()
{
int x;
int fd[2];
char buf[BUFFER_SIZE];
char s[BUFFER_SIZE];
pipe(fd);//創建管道
while((x=fork())==-1);//創建管道失敗時，進入循環

/*進入子進程，子進程向管道中寫入一個字元串*/
if(x==0)
{
sprintf(buf,"This is an example of pipe!/n");
write(fd[1],buf,BUFFER_SIZE);
exit(0);
}

/*進入父進程，父進程從管道的另一端讀出剛才寫入的字元串*/
else
{
wait(0);//等待子進程結束
read(fd[0],s,BUFFER_SIZE);//讀出字元串，並將其儲存在char s[]中
printf("%s",s);//列印字元串
}
return 0;
}

三.進程間通信——IPC

①信號量通信

sem.c

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>

/*聯合體變數*/
union semun
{
int val; //信號量初始值
struct semid_ds *buf;
unsigned short int *array;
struct seminfo *__buf;
};

/*函數聲明，信號量定義*/
static int set_semvalue(void); //設置信號量
static void del_semvalue(void);//刪除信號量
static int semaphore_p(void); //執行P操作
static int semaphore_v(void); //執行V操作
static int sem_id; //信號量標識符

int main(int argc, char *argv[])
{
int i;
int pause_time;
char op_char = 'O';
srand((unsigned int)getpid());
sem_id = semget((key_t)1234, 1, 0666 | IPC_CREAT);//創建一個信號量,IPC_CREAT表示創建一個新的信號量

/*如果有參數，設置信號量，修改字元*/
if (argc > 1)
{
if (!set_semvalue())
{
fprintf(stderr, "Failed to initialize semaphore/n");
exit(EXIT_FAILURE);
}
op_char = 'X';
sleep(5);
}
for(i = 0; i < 10; i++)
{

/*執行P操作*/
if (!semaphore_p())
exit(EXIT_FAILURE);
printf("%c", op_char);
fflush(stdout);
pause_time = rand() % 3;
sleep(pause_time);
printf("%c", op_char);
fflush(stdout);

/*執行V操作*/
if (!semaphore_v())
exit(EXIT_FAILURE);
pause_time = rand() % 2;
sleep(pause_time);
}
printf("/n%d - finished/n", getpid());
if (argc > 1)
{
sleep(10);
del_semvalue(); //刪除信號量
}
exit(EXIT_SUCCESS);
}

/*設置信號量*/
static int set_semvalue(void)
{
union semun sem_union;
sem_union.val = 1;
if (semctl(sem_id, 0, SETVAL, sem_union) == -1)
return(0);

return(1);
}

/*刪除信號量*/
static void del_semvalue(void)
{
union semun sem_union;
if (semctl(sem_id, 0, IPC_RMID, sem_union) == -1)
fprintf(stderr, "Failed to delete semaphore/n");
}

/*執行P操作*/
static int semaphore_p(void)
{
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = -1; /* P() */
sem_b.sem_flg = SEM_UNDO;
if (semop(sem_id, &sem_b, 1) == -1)
{
fprintf(stderr, "semaphore_p failed/n");
return(0);
}
return(1);
}

/*執行V操作*/
static int semaphore_v(void)
{
struct sembuf sem_b;
sem_b.sem_num = 0;
sem_b.sem_op = 1; /* V() */
sem_b.sem_flg = SEM_UNDO;
if (semop(sem_id, &sem_b, 1) == -1)
{
fprintf(stderr, "semaphore_v failed/n");
return(0);
}
return(1);
}

②消息隊列通信

send.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#define MAX_TEXT 512

/*用於消息收發的結構體--my_msg_type：消息類型，some_text：消息正文*/
struct my_msg_st
{
long int my_msg_type;
char some_text[MAX_TEXT];
};

int main()
{
int running = 1;//程序運行標識符
struct my_msg_st some_data;
int msgid;//消息隊列標識符
char buffer[BUFSIZ];

/*創建與接受者相同的消息隊列*/
msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
if (msgid == -1)
{
fprintf(stderr, "msgget failed with error: %d/n", errno);
exit(EXIT_FAILURE);
}

/*向消息隊列中發送消息*/
while(running)
{
printf("Enter some text: ");
fgets(buffer, BUFSIZ, stdin);
some_data.my_msg_type = 1;
strcpy(some_data.some_text, buffer);
if (msgsnd(msgid, (void *)&some_data, MAX_TEXT, 0) == -1)
{
fprintf(stderr, "msgsnd failed/n");
exit(EXIT_FAILURE);
}
if (strncmp(buffer, "end", 3) == 0)
{
running = 0;
}
}
exit(EXIT_SUCCESS);
}

receive.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>

/*用於消息收發的結構體--my_msg_type：消息類型，some_text：消息正文*/
struct my_msg_st
{
long int my_msg_type;
char some_text[BUFSIZ];
};

int main()
{
int running = 1;//程序運行標識符
int msgid; //消息隊列標識符
struct my_msg_st some_data;
long int msg_to_receive = 0;//接收消息的類型--0表示msgid隊列上的第一個消息

/*創建消息隊列*/
msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
if (msgid == -1)
{
fprintf(stderr, "msgget failed with error: %d/n", errno);
exit(EXIT_FAILURE);
}

/*接收消息*/
while(running)
{
if (msgrcv(msgid, (void *)&some_data, BUFSIZ,msg_to_receive, 0) == -1)
{
fprintf(stderr, "msgrcv failed with error: %d/n", errno);
exit(EXIT_FAILURE);
}
printf("You wrote: %s", some_data.some_text);
if (strncmp(some_data.some_text, "end", 3) == 0)
{
running = 0;
}
}

/*刪除消息隊列*/
if (msgctl(msgid, IPC_RMID, 0) == -1)
{
fprintf(stderr, "msgctl(IPC_RMID) failed/n");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}

③共享內存通信

share.h

#define TEXT_SZ 2048 //申請共享內存大小
struct shared_use_st
{
int written_by_you; //written_by_you為1時表示有數據寫入，為0時表示數據已經被消費者提走
char some_text[TEXT_SZ];
};

procer.c

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "share.h"

int main()
{
int running = 1; //程序運行標志位
void *shared_memory = (void *)0;
struct shared_use_st *shared_stuff;
char buffer[BUFSIZ];
int shmid; //共享內存標識符

/*創建共享內存*/
shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT);
if (shmid == -1)
{
fprintf(stderr, "shmget failed/n");
exit(EXIT_FAILURE);
}

/*將共享內存連接到一個進程的地址空間中*/
shared_memory = shmat(shmid, (void *)0, 0);//指向共享內存第一個位元組的指針
if (shared_memory == (void *)-1)
{
fprintf(stderr, "shmat failed/n");
exit(EXIT_FAILURE);
}
printf("Memory attached at %X/n", (int)shared_memory);
shared_stuff = (struct shared_use_st *)shared_memory;

/*生產者寫入數據*/
while(running)
{
while(shared_stuff->written_by_you == 1)
{
sleep(1);
printf("waiting for client.../n");
}
printf("Enter some text: ");
fgets(buffer, BUFSIZ, stdin);
strncpy(shared_stuff->some_text, buffer, TEXT_SZ);
shared_stuff->written_by_you = 1;
if (strncmp(buffer, "end", 3) == 0)
{
running = 0;
}
}

/*該函數用來將共享內存從當前進程中分離,僅使得當前進程不再能使用該共享內存*/
if (shmdt(shared_memory) == -1)
{
fprintf(stderr, "shmdt failed/n");
exit(EXIT_FAILURE);
}
printf("procer exit./n");
exit(EXIT_SUCCESS);
}

customer.c

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include "share.h"

int main()
{
int running = 1;//程序運行標志位
void *shared_memory = (void *)0;
struct shared_use_st *shared_stuff;
int shmid; //共享內存標識符
srand((unsigned int)getpid());

/*創建共享內存*/
shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666 | IPC_CREAT);
if (shmid == -1)
{
fprintf(stderr, "shmget failed/n");
exit(EXIT_FAILURE);
}

/*將共享內存連接到一個進程的地址空間中*/
shared_memory = shmat(shmid, (void *)0, 0);//指向共享內存第一個位元組的指針
if (shared_memory == (void *)-1)
{
fprintf(stderr, "shmat failed/n");
exit(EXIT_FAILURE);
}
printf("Memory attached at %X/n", (int)shared_memory);
shared_stuff = (struct shared_use_st *)shared_memory;
shared_stuff->written_by_you = 0;

/*消費者讀取數據*/
while(running)
{
if (shared_stuff->written_by_you)
{
printf("You wrote: %s", shared_stuff->some_text);
sleep( rand() % 4 );
shared_stuff->written_by_you = 0;
if (strncmp(shared_stuff->some_text, "end", 3) == 0)
{
running = 0;
}
}
}

/*該函數用來將共享內存從當前進程中分離,僅使得當前進程不再能使用該共享內存*/
if (shmdt(shared_memory) == -1)
{
fprintf(stderr, "shmdt failed/n");
exit(EXIT_FAILURE);
}

/*將共享內存刪除,所有進程均不能再訪問該共享內存*/
if (shmctl(shmid, IPC_RMID, 0) == -1)
{
fprintf(stderr, "shmctl(IPC_RMID) failed/n");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}

摘自：http://blog.csdn.net/piaojun_pj/article/details/5943736

4. Linux系統編程—消息隊列

消息隊列本質上是位於內核空間的鏈表，鏈表的每個節點都是一條消息。每一條消息都有自己的消息類型，消息類型用整數來表示，而且必須大於 0。每種類型的消息都被對應的鏈表所維護：

其中數字 1 表示類型為 1 的消息，數字2、3、4 類似。彩色塊表示消息數據，它們被掛在對應類型的鏈表上。

值得注意的是，剛剛說過沒有消息類型為 0 的消息，實際上，消息類型為 0 的鏈表記錄了所有消息加入隊列的順序，其中紅色箭頭表示消息加入的順序。

無論你是發送還是接收消息，消息的格式都必須按照規范來。簡單的說，它一般長成下面這個樣子：

所以，只要你保證首4位元組(32 位 linux 下的 long)是一個整數就行了。
舉個例子：

從上面可以看出，正文部分是什麼數據類型都沒關系，因為消息隊列傳遞的是 2 進制數據，不一定非得是文本。

msgsnd 函數用於將數據發送到消息隊列。如果該函數被信號打斷，會設置 errno 為 EINTR。

參數 msqid：ipc 內核對象 id
參數 msgp：消息數據地址
參數 msgsz：消息正文部分的大小（不包含消息類型）
參數 msgflg：可選項
該值為 0：如果消息隊列空間不夠，msgsnd 會阻塞。
IPC_NOWAIT：直接返回，如果空間不夠，會設置 errno 為 EAGIN.

返回值：0 表示成功，-1 失敗並設置 errno。

msgrcv 函數從消息隊列取出消息後，並將其從消息隊列里刪除。

參數 msqid：ipc 內核對象 id
參數 msgp：用來接收消息數據地址
參數 msgsz：消息正文部分的大小（不包含消息類型）
參數 msgtyp：指定獲取哪種類型的消息

msgtyp = 0：獲取消息隊列中的第一條消息
msgtyp > 0：獲取類型為 msgtyp 的第一條消息，除非指定了 msgflg 為MSG_EXCEPT，這表示獲取除了 msgtyp 類型以外的第一條消息。
msgtyp < 0：獲取類型 ≤|msgtyp|≤|msgtyp| 的第一條消息。
參數 msgflg：可選項。
如果為 0 表示沒有消息就阻塞。
IPC_NOWAIT：如果指定類型的消息不存在就立即返回，同時設置 errno 為 ENOMSG
MSG_EXCEPT：僅用於 msgtyp > 0 的情況。表示獲取類型不為 msgtyp 的消息
MSG_NOERROR：如果消息數據正文內容大於 msgsz，就將消息數據截斷為 msgsz

程序 msg_send 和 msg_recv 分別用於向消息隊列發送數據和接收數據。

msg_send 程序定義了一個結構體 Msg，消息正文部分是結構體 Person。該程序向消息隊列發送了 10 條消息。
msg_send.c

程序 msg_send 第一次運行完後，內核中的消息隊列大概像下面這樣：

msg_recv 程序接收一個參數，表示接收哪種類型的消息。比如./msg_recv 4 表示接收類型為 4 的消息，並列印在屏幕。

先運行 msg_send，再運行 msg_recv。
接收所有消息

接收類型為 4 的消息

獲取和設置消息隊列的屬性

msqid：消息隊列標識符
cmd：控制指令
IPC_STAT:獲得msgid的消息隊列頭數據到buf中
IPC_SET：設置消息隊列的屬性，要設置的屬性需先存儲在buf中，可設置的屬性包括：msg_perm.uid、msg_perm.gid、msg_perm.mode以及msg_qbytes
buf：消息隊列管理結構體。

返回值：
成功：0
出錯：-1，錯誤原因存於error中
EACCESS：參數cmd為IPC_STAT，確無許可權讀取該消息隊列
EFAULT：參數buf指向無效的內存地址
EIDRM：標識符為msqid的消息隊列已被刪除
EINVAL：無效的參數cmd或msqid
EPERM：參數cmd為IPC_SET或IPC_RMID，卻無足夠的許可權執行

5. linux系統的進程間通信有哪幾種方式

一、方式

1、管道（Pipe）及有名管道（ mkpipe）：

管道可用於具有親緣關系進程間的通信，有名管道克服了管道沒有名字的限制，因此，除具有管道所具有的功能外，它還允許無親緣關系進程間的通信；

2、信號（Signal）：

信號是比較復雜的通信方式，用於通知接受進程有某種事件發生，除了用於進程間通信外，進程還可以發送信號給進程本身。

linux除了支持Unix早期信號語義函數sigal外，還支持語義符合Posix.1標準的信號函數sigaction。

實際上，該函數是基於BSD的，BSD為了實現可靠信號機制，又能夠統一對外介面，用sigaction函數重新實現了signal函數。

3、消息隊列（Message）：

消息隊列是消息的鏈接表，包括Posix消息隊列system V消息隊列。有足夠許可權的進程可以向隊列中添加消息，被賦予讀許可權的進程則可以讀走隊列中的消息。消息隊列克服了信號承載信息量少，管道只能承載無格式位元組流以及緩沖區大小受限等缺點。

4、共享內存：

使得多個進程可以訪問同一塊內存空間，是最快的可用IPC形式。是針對其他通信機制運行效率較低而設計的。往往與其它通信機制，如信號量結合使用，來達到進程間的同步及互斥。

5、信號量（semaphore）：

主要作為進程間以及同一進程不同線程之間的同步手段。

6、套介面（Socket）：

更為一般的進程間通信機制，可用於不同機器之間的進程間通信。起初是由Unix系統的BSD分支開發出來的，但現在一般可以移植到其它類Unix系統上：Linux和System V的變種都支持套接字。

二、概念

進程間通信概念：

IPC—-InterProcess Communication

每個進程各自有不同的用戶地址空間,任何一個進程的全局變數在另一個進程中都看不到所以進程之間要交換數據必須通過內核。

在內核中開辟一塊緩沖區,進程1把數據從用戶空間拷到內核緩沖區,進程2再從內核緩沖區把數據讀走,內核提供的這種機制稱為進程間通信。

(5)linux消息隊列相互通信擴展閱讀

1）無名管道:

管道是半雙工的，數據只能向一個方向流動；需要雙方通信時，需要建立起兩個管道；只能用於父子進程或者兄弟進程之間（具有親緣關系的進程）。

管道對於管道兩端的進程而言，就是一個文件，但它不是普通的文件，它不屬於某種文件系統，構成兩進程間通信的一個媒介。

數據的讀出和寫入：一個進程向管道中寫的內容被管道另一端的進程讀出。寫入的內容每次都添加在管道緩沖區的末尾，並且每次都是從緩沖區的頭部讀出數據。

2）有名管道：

不同於管道之處在於它提供一個路徑名與之關聯，以FIFO的文件形式存在於文件系統中。這樣，即使與FIFO的創建進程不存在親緣關系的進程，只要可以訪問該路徑，就能夠彼此通過FIFO相互通信（能夠訪問該路徑的進程以及FIFO的創建進程之間）。

因此，通過FIFO不相關的進程也能交換數據。值得注意的是，FIFO嚴格遵循先進先出（first in first out），對管道及FIFO的讀總是從開始處返回數據，對它們的寫則把數據添加到末尾。它們不支持諸如lseek()等文件定位操作。

6. Linux進程間通信

linux下進程間通信的幾種主要手段簡介：

一般文件的I/O函數都可以用於管道，如close、read、write等等。

實例1：用於shell

管道可用於輸入輸出重定向，它將一個命令的輸出直接定向到另一個命令的輸入。比如，當在某個shell程序（Bourne shell或C shell等）鍵入who│wc -l後，相應shell程序將創建who以及wc兩個進程和這兩個進程間的管道。

實例二：用於具有親緣關系的進程間通信

管道的主要局限性正體現在它的特點上：

有名管道的創建

小結：

管道常用於兩個方面：（1）在shell中時常會用到管道（作為輸入輸入的重定向），在這種應用方式下，管道的創建對於用戶來說是透明的；（2）用於具有親緣關系的進程間通信，用戶自己創建管道，並完成讀寫操作。

FIFO可以說是管道的推廣，克服了管道無名字的限制，使得無親緣關系的進程同樣可以採用先進先出的通信機制進行通信。

管道和FIFO的數據是位元組流，應用程序之間必須事先確定特定的傳輸"協議"，採用傳播具有特定意義的消息。

要靈活應用管道及FIFO，理解它們的讀寫規則是關鍵。

信號生命周期

信號是進程間通信機制中唯一的非同步通信機制，可以看作是非同步通知，通知接收信號的進程有哪些事情發生了。信號機制經過POSIX實時擴展後，功能更加強大，除了基本通知功能外，還可以傳遞附加信息。

可以從兩個不同的分類角度對信號進行分類：（1）可靠性方面：可靠信號與不可靠信號；（2）與時間的關繫上：實時信號與非實時信號。

(1) 可靠信號與不可靠信號

不可靠信號 ：Linux下的不可靠信號問題主要指的是信號可能丟失。

可靠信號 ：信號值位於SIGRTMIN和SIGRTMAX之間的信號都是可靠信號，可靠信號克服了信號可能丟失的問題。Linux在支持新版本的信號安裝函數sigation（）以及信號發送函數sigqueue()的同時，仍然支持早期的signal（）信號安裝函數，支持信號發送函數kill()。

對於目前linux的兩個信號安裝函數:signal()及sigaction()來說，它們都不能把SIGRTMIN以前的信號變成可靠信號（都不支持排隊，仍有可能丟失，仍然是不可靠信號），而且對SIGRTMIN以後的信號都支持排隊。這兩個函數的最大區別在於，經過sigaction安裝的信號都能傳遞信息給信號處理函數（對所有信號這一點都成立），而經過signal安裝的信號卻不能向信號處理函數傳遞信息。對於信號發送函數來說也是一樣的。

(2) 實時信號與非實時信號

前32種信號已經有了預定義值，每個信號有了確定的用途及含義，並且每種信號都有各自的預設動作。如按鍵盤的CTRL ^C時，會產生SIGINT信號，對該信號的默認反應就是進程終止。後32個信號表示實時信號，等同於前面闡述的可靠信號。這保證了發送的多個實時信號都被接收。實時信號是POSIX標準的一部分，可用於應用進程。非實時信號都不支持排隊，都是不可靠信號；實時信號都支持排隊，都是可靠信號。

發送信號的主要函數有：kill()、raise()、 sigqueue()、alarm()、setitimer()以及abort()。

調用成功返回 0；否則，返回 -1。

sigqueue()是比較新的發送信號系統調用，主要是針對實時信號提出的（當然也支持前32種），支持信號帶有參數，與函數sigaction()配合使用。

sigqueue的第一個參數是指定接收信號的進程ID，第二個參數確定即將發送的信號，第三個參數是一個聯合數據結構union sigval，指定了信號傳遞的參數，即通常所說的4位元組值。

sigqueue()比kill()傳遞了更多的附加信息，但sigqueue()只能向一個進程發送信號。sigqueue()比kill()傳遞了更多的附加信息，但sigqueue()只能向一個進程發送信號。

inux主要有兩個函數實現信號的安裝： signal() 、 sigaction() 。其中signal()在可靠信號系統調用的基礎上實現, 是庫函數。它只有兩個參數，不支持信號傳遞信息，主要是用於前32種非實時信號的安裝；而sigaction()是較新的函數（由兩個系統調用實現：sys_signal以及sys_rt_sigaction），有三個參數，支持信號傳遞信息，主要用來與 sigqueue() 系統調用配合使用，當然，sigaction()同樣支持非實時信號的安裝。sigaction()優於signal()主要體現在支持信號帶有參數。

消息隊列就是一個消息的鏈表。可以把消息看作一個記錄，具有特定的格式以及特定的優先順序。對消息隊列有寫許可權的進程可以向中按照一定的規則添加新消息；對消息隊列有讀許可權的進程則可以從消息隊列中讀走消息。消息隊列是隨內核持續的

消息隊列的內核持續性要求每個消息隊列都在系統范圍內對應唯一的鍵值，所以，要獲得一個消息隊列的描述字，只需提供該消息隊列的鍵值即可；

消息隊列與管道以及有名管道相比，具有更大的靈活性，首先，它提供有格式位元組流，有利於減少開發人員的工作量；其次，消息具有類型，在實際應用中，可作為優先順序使用。這兩點是管道以及有名管道所不能比的。同樣，消息隊列可以在幾個進程間復用，而不管這幾個進程是否具有親緣關系，這一點與有名管道很相似；但消息隊列是隨內核持續的，與有名管道（隨進程持續）相比，生命力更強，應用空間更大。

信號燈與其他進程間通信方式不大相同，它主要提供對進程間共享資源訪問控制機制。相當於內存中的標志，進程可以根據它判定是否能夠訪問某些共享資源，同時，進程也可以修改該標志。除了用於訪問控制外，還可用於進程同步。信號燈有以下兩種類型：

int semop(int semid, struct sembuf *sops, unsigned nsops); semid是信號燈集ID，sops指向數組的每一個sembuf結構都刻畫一個在特定信號燈上的操作。

int semctl(int semid，int semnum，int cmd，union semun arg)
該系統調用實現對信號燈的各種控制操作，參數semid指定信號燈集，參數cmd指定具體的操作類型；參數semnum指定對哪個信號燈操作，只對幾個特殊的cmd操作有意義；arg用於設置或返回信號燈信息。

進程間需要共享的數據被放在一個叫做IPC共享內存區域的地方，所有需要訪問該共享區域的進程都要把該共享區域映射到本進程的地址空間中去。系統V共享內存通過shmget獲得或創建一個IPC共享內存區域，並返回相應的標識符。內核在保證shmget獲得或創建一個共享內存區，初始化該共享內存區相應的shmid_kernel結構注同時，還將在特殊文件系統shm中，創建並打開一個同名文件，並在內存中建立起該文件的相應dentry及inode結構，新打開的文件不屬於任何一個進程（任何進程都可以訪問該共享內存區）。所有這一切都是系統調用shmget完成的。

shmget（）用來獲得共享內存區域的ID，如果不存在指定的共享區域就創建相應的區域。shmat()把共享內存區域映射到調用進程的地址空間中去，這樣，進程就可以方便地對共享區域進行訪問操作。shmdt()調用用來解除進程對共享內存區域的映射。shmctl實現對共享內存區域的控制操作。這里我們不對這些系統調用作具體的介紹，讀者可參考相應的手冊頁面，後面的範例中將給出它們的調用方法。

註：shmget的內部實現包含了許多重要的系統V共享內存機制；shmat在把共享內存區域映射到進程空間時，並不真正改變進程的頁表。當進程第一次訪問內存映射區域訪問時，會因為沒有物理頁表的分配而導致一個缺頁異常，然後內核再根據相應的存儲管理機制為共享內存映射區域分配相應的頁表。

7. linux c語言進程間通信疑問，上述程序只是想父進程創建一個消息隊列，發給子進程消息，但是為什麼沒有成功

把
if((msgid=msgget(IPC_PRIVATE,0666))==-1)
{
printf("error111");
exit(0);
}
放到fork()函數之前就可以了。

創建消息隊列需要在fork()之前，因為fork()產生的是兩個進程，他們的資源是相互獨立的。

fork()之後創建的消息隊列，另一個進程不能識別。

8. Linux - 進程間通信與線程通信方式

每個進程的用戶地址空間都是獨立的，一般而言是不能互相訪問的，但內核空間是每個進程都共享的，所以進程之間要通信必須通過內核。

上面命令行里的「|」豎線就是一個管道，它的功能是將前一個命令（ps auxf）的輸出，作為後一個命令（grep mysql）的輸入，從這功能描述，可以看出管道傳輸數據是單向的，如果想相互通信，我們需要創建兩個管道才行。

同時，我們得知上面這種管道是沒有名字，所以「|」表示的管道稱為匿名管道，用完了就銷毀。

管道還有另外一個類型是命名管道，也被叫做 FIFO，因為數據是先進先出的傳輸方式。

在使用命名管道前，先需要通過 mkfifo 命令來創建，並且指定管道名字

myPipe 就是這個管道的名稱，基於 Linux 一切皆文件的理念，所以管道也是以文件的方式存在，我們可以用 ls 看一下，這個文件的類型是 p，也就是 pipe（管道） 的意思：

你操作了後，你會發現命令執行後就停在這了，這是因為管道里的內容沒有被讀取，只有當管道里的數據被讀完後，命令才可以正常退出。

於是，我們執行另外一個命令來讀取這個管道里的數據：

可以看到，管道里的內容被讀取出來了，並列印在了終端上，另外一方面，echo 那個命令也正常退出了。

我們可以看出，管道這種通信方式效率低，不適合進程間頻繁地交換數據。當然，它的好處，自然就是簡單，同時也我們很容易得知管道里的數據已經被另一個進程讀取了。

前面說到管道的通信方式是效率低的，因此管道不適合進程間頻繁地交換數據。

對於這個問題，消息隊列的通信模式就可以解決。比如，A 進程要給 B 進程發送消息，A 進程把數據放在對應的消息隊列後就可以正常返回了，B 進程需要的時候再去讀取數據就可以了。同理，B 進程要給 A 進程發送消息也是如此。

再來，消息隊列是保存在內核中的消息鏈表，在發送數據時，會分成一個一個獨立的數據單元，也就是消息體（數據塊），消息體是用戶自定義的數據類型，消息的發送方和接收方要約定好消息體的數據類型，所以每個消息體都是固定大小的存儲塊，不像管道是無格式的位元組流數據。如果進程從消息隊列中讀取了消息體，內核就會把這個消息體刪除。

消息隊列生命周期隨內核，如果沒有釋放消息隊列或者沒有關閉操作系統，消息隊列會一直存在，而前面提到的匿名管道的生命周期，是隨進程的創建而建立，隨進程的結束而銷毀。

消息這種模型，兩個進程之間的通信就像平時發郵件一樣，你來一封，我回一封，可以頻繁溝通了。

但郵件的通信方式存在不足的地方有兩點，一是通信不及時，二是附件也有大小限制，這同樣也是消息隊列通信不足的點。

消息隊列不適合比較大數據的傳輸，因為在內核中每個消息體都有一個最大長度的限制，同時所有隊列所包含的全部消息體的總長度也是有上限。在 Linux 內核中，會有兩個宏定義 MSGMAX 和 MSGMNB，它們以位元組為單位，分別定義了一條消息的最大長度和一個隊列的最大長度。

消息隊列通信過程中，存在用戶態與內核態之間的數據拷貝開銷，因為進程寫入數據到內核中的消息隊列時，會發生從用戶態拷貝數據到內核態的過程，同理另一進程讀取內核中的消息數據時，會發生從內核態拷貝數據到用戶態的過程。

消息隊列的讀取和寫入的過程，都會有發生用戶態與內核態之間的消息拷貝過程。那共享內存的方式，就很好的解決了這一問題。

現代操作系統，對於內存管理，採用的是虛擬內存技術，也就是每個進程都有自己獨立的虛擬內存空間，不同進程的虛擬內存映射到不同的物理內存中。所以，即使進程 A 和 進程 B 的虛擬地址是一樣的，其實訪問的是不同的物理內存地址，對於數據的增刪查改互不影響。

用了共享內存通信方式，帶來新的問題，那就是如果多個進程同時修改同一個共享內存，很有可能就沖突了。例如兩個進程都同時寫一個地址，那先寫的那個進程會發現內容被別人覆蓋了。

為了防止多進程競爭共享資源，而造成的數據錯亂，所以需要保護機制，使得共享的資源，在任意時刻只能被一個進程訪問。正好，信號量就實現了這一保護機制。

信號量其實是一個整型的計數器，主要用於實現進程間的互斥與同步，而不是用於緩存進程間通信的數據。

信號量表示資源的數量，控制信號量的方式有兩種原子操作：

P 操作是用在進入共享資源之前，V 操作是用在離開共享資源之後，這兩個操作是必須成對出現的。

接下來，舉個例子，如果要使得兩個進程互斥訪問共享內存，我們可以初始化信號量為 1。

具體的過程如下：

可以發現，信號初始化為 1，就代表著是互斥信號量，它可以保證共享內存在任何時刻只有一個進程在訪問，這就很好的保護了共享內存。

另外，在多進程里，每個進程並不一定是順序執行的，它們基本是以各自獨立的、不可預知的速度向前推進，但有時候我們又希望多個進程能密切合作，以實現一個共同的任務。

例如，進程 A 是負責生產數據，而進程 B 是負責讀取數據，這兩個進程是相互合作、相互依賴的，進程 A 必須先生產了數據，進程 B 才能讀取到數據，所以執行是有前後順序的。

那麼這時候，就可以用信號量來實現多進程同步的方式，我們可以初始化信號量為 0。

具體過程：

可以發現，信號初始化為 0，就代表著是同步信號量，它可以保證進程 A 應在進程 B 之前執行。

跨機器進程間通信方式

同個進程下的線程之間都是共享進程的資源，只要是共享變數都可以做到線程間通信，比如全局變數，所以對於線程間關注的不是通信方式，而是關注多線程競爭共享資源的問題，信號量也同樣可以在線程間實現互斥與同步：

9. linux 消息隊列進程通信問題，能發送消息，但接收時接收不到，停在那裡等，請指導下

可定義一個大的char buff[2048] 大於sizeof（msg2）就行，試試

(msgrcv(iMsgid2, buff, iType, 100, 0) == -1