c語言進程通信
B.1 正常退出。
man的解析。
WIFEXITED(status)
returns true if the child terminated normally, that is, by call‐
ing exit(3) or _exit(2), or by returning from main().
真就是1，假就是0.
B. 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
C. 利用C語言寫一個程序實現兩個進程間進行管道通信
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#define N 10
#define MAX 100
int child_read_pipe(int fd)
{
char buf[N];
int n = 0;
while(1)
{
n = read(fd,buf,sizeof(buf));
buf[n] = '\0';
printf("Read %d bytes : %s.\n",n,buf);
if(strncmp(buf,"quit",4) == 0)
break;
}
return 0;
}
int father_write_pipe(int fd)
{
char buf[MAX] = {0};
while(1)
{
printf(">");
fgets(buf,sizeof(buf),stdin);
buf[strlen(buf)-1] = '\0';
write(fd,buf,strlen(buf));
usleep(500);
if(strncmp(buf,"quit",4) == 0)
break;
}
return 0;
}
int main()
{
int pid;
int fd[2];
if(pipe(fd) < 0)
{
perror("Fail to pipe");
exit(EXIT_FAILURE);
}
if((pid = fork()) < 0)
{
perror("Fail to fork");
exit(EXIT_FAILURE);
}else if(pid == 0){
close(fd[1]);
child_read_pipe(fd[0]);
}else{
close(fd[0]);
father_write_pipe(fd[1]);
}
exit(EXIT_SUCCESS);
}
D. 用c語言編寫的進程管理程序
#include<conio.h>
#include<stdio.h>
#include<windows.h>
#include<stdlib.h>
#include<string.h>
structPCB_type
{charpid[100];//進程名輸入用字元串健壯性比較好
intpriority;
intcputime;
intstate;
};//缺少「};」
intshumu=0,pid_l;
structPCB_typeneicun[20];
structPCB_typehc[10];
intmax=0;
intnumber=0;
voidcreate();
voidrun();
voidhuanchu();
voidkill();
intmain()
{
intn,a;
n=1;
system("color1d");
while(n==1)
{
system("cls");
printf(" **********************************************");
printf(" *進程演示系統*");
printf(" **********************************************");
printf(" 1.創建新的進程2.查看運行進程");
printf(" 3.換出某個進程4.殺死運行進程");//新增了一個喚醒功能
printf(" 5.退出系統");
printf(" **********************************************");
printf(" 請選擇(1～5):");
scanf("%d",&a);
switch(a)
{case1:
create();
printf(" pressanykeytogoon~");
getch();
break;
case2:
run();
printf(" pressanykeytogoon~");
getch();
break;
case3:
huanchu();
printf(" pressanykeytogoon~");
getch();
break;
case4:
kill();
printf(" pressanykeytogoon~");
getch();
break;
case5:
exit(0);
default:
n=1;
break;
}
}
}
voidcreate()
{
if(shumu>=20)
{
printf(" 內存已滿，請先結束或換出進程 ");
}
else
{
shumu++;
printf(" 請輸入新進程的程序名 ");
scanf("%s",neicun[shumu-1].pid);
printf(" 請輸入新進程的優先順序(數字) ");//
scanf("%d",&neicun[shumu-1].priority);
printf(" 請輸入新進程的需要的運行時間 ");//
scanf("%d",&neicun[shumu-1].cputime);
printf(" 創建進程時令其狀態為就緒 ");
neicun[shumu-1].state=2;//1為等待，2就緒，3為運行
}
printf(" 創建進程成功! ");
}
voidrun()
{
if(shumu<=0)//查看//判斷是否存在進程
{
printf("當前狀態無進程,按任意鍵繼續創建進程 ");
return;
}
intmax=0;
for(inti=0;i<shumu;i++)//
if((neicun[i].state==2&&neicun[i].priority>=neicun[max].priority))
{
max=i;//這里判斷優先順序，優先順序高的進程優先執行。
}
if(neicun[max].state==2)
{
neicun[max].state=3;//進程運行，狀態為3
system("color5F");
printf("/*********************當前已有進程%d個*************************/: ",shumu);
for(inti=0;i<shumu;i++){
printf("進程編號:%d",i+1);
printf(" /***********正在運行進程程序名:%s*************************/ ",neicun[i].pid);
printf(" /***********該進程的優先順序:%d*****************************/ ",neicun[i].priority);
printf(" /***********該進程的需要運行時間:%d***********************/ ",neicun[i].cputime);
printf(" /***********該進程的狀態:%d(1為等待，2就緒，3為運行)******/ ",neicun[i].state);}//這里增加顯示當前運行的進程
}
}
/*換出*/
voidhuanchu()
{
intk;
if(shumu<=0)//判斷是否存在進程
{
printf("當前進程數目為0,不能執行該操作 ");
return;
}
printf("當前已有進程%d個: ",shumu);
for(inth=0;h<shumu;h++)//當前所有的進程
printf("序號:%d 程序名:%s 優先順序:%d 運行時間:%d 狀態:%d "
,h,neicun[h].pid,neicun[h].priority,neicun[h].cputime,neicun[h].state);
printf("請輸入要換出程序的序號:");
scanf("%d",&k);
if(neicun[k].state==3)
{
neicun[k].state=1;
printf("已被換出,進程名為:%s、狀態為:[%d]",neicun[k].pid,neicun[k].state);
}
else
printf("無法換出，進程名為:%s的進程",neicun[k].pid);//換出結果提示
}
voidkill()
{
if(shumu<=0)//對存在的進程進行判斷
{
printf("當前進程數目為0,不能執行該操作 ");
return;
}
intk=0;
printf("/******************當前已有進程%d個******************/: ",shumu);
for(inth=0;h<shumu;h++)//當前所有的進程
printf("序號:%d 程序名:%s 優先順序:%d 運行時間:%d 狀態:%d "
,h,neicun[h].pid,neicun[h].priority,neicun[h].cputime,neicun[h].state);
printf("請輸入要殺死程序的序號:");
scanf("%d",&k);
neicun[k].cputime=0;
neicun[k].priority=0;
neicun[k].state=0;
if(k==(shumu-1))
shumu--;
else{
for(intj=k+1;j<shumu;j++)
{
strcmp(neicun[j-1].pid,neicun[j].pid);
neicun[j-1].priority=neicun[j].priority;
neicun[j-1].cputime=neicun[j].cputime;
neicun[j-1].state=neicun[j].state;
}
shumu--;
}
printf("進程名為:%s已被殺死! ",neicun[k].pid);//顯示進程已被殺死
}
E. linux c語言進程間通信疑問，上述程序只是想父進程創建一個消息隊列，發給子進程消息，但是為什麼沒有成功
把
if((msgid=msgget(IPC_PRIVATE,0666))==-1)
{
printf("error111");
exit(0);
}
放到fork()函數之前就可以了。
創建消息隊列需要在fork()之前，因為fork()產生的是兩個進程，他們的資源是相互獨立的。
fork()之後創建的消息隊列，另一個進程不能識別。
F. 進程間通信方式
在操作系統中，一個進程可以理解為是關於計算機資源集合的一次運行活動，其就是一個正在執行的程序的實例。從概念上來說，一個進程擁有它自己的虛擬CPU和虛擬地址空間，任何一個進程對於彼此而言都是相互獨立的，這也引入了一個問題 —— 如何讓進程之間互相通信？
由於進程之間是互相獨立的，沒有任何手段直接通信，因此我們需要藉助操作系統來輔助它們。舉個通俗的例子，假如A與B之間是獨立的，不能彼此聯系，如果它們想要通信的話可以藉助第三方C，比如A將信息交給C，C再將信息轉交給B —— 這就是進程間通信的主要思想 —— 共享資源。
這里要解決的一個重要的問題就是如何避免競爭，即避免多個進程同時訪問臨界區的資源。
共享內存是進程間通信中最簡單的方式之一。共享內存允許兩個或更多進程訪問同一塊內存。當一個進程改變了這塊地址中的內容的時候，其它進程都會察覺到這個更改。
你可能會想到，我直接創建一個文件，然後進程不就都可以訪問了？
是的，但這個方法有幾個缺陷：
Linux下採用共享內存的方式來使進程完成對共享資源的訪問，它將磁碟文件復制到內存，並創建虛擬地址到該內存的映射，就好像該資源本來就在進程空間之中，此後我們就可以像操作本地變數一樣去操作它們了，實際的寫入磁碟將由系統選擇最佳方式完成，例如操作系統可能會批量處理加排序，從而大大提高IO速度。
如同上圖一樣，進程將共享內存映射到自己的虛擬地址空間中，進程訪問共享進程就好像在訪問自己的虛擬內存一樣，速度是非常快的。
共享內存的模型應該是比較好理解的：在物理內存中創建一個共享資源文件，進程將該共享內存綁定到自己的虛擬內存之中。
這里要解決的一個問題是如何將同一塊共享內存綁定到自己的虛擬內存中，要知道在不同進程中使用 malloc 函數是會順序分配空閑內存，而不會分配同一塊內存，那麼要如何去解決這個問題呢？
Linux操作系統已經想辦法幫我們解決了這個問題，在 #include <sys/ipc.h> 和 #include <sys/shm.h> 頭文件下，有如下幾個shm系列函數：
通過上述幾個函數，每個獨立的進程只要有統一的共享內存標識符便可以建立起虛擬地址到物理地址的映射，每個虛擬地址將被翻譯成指向共享區域的物理地址，這樣就實現了對共享內存的訪問。
還有一種相像的實現是採用mmap函數，mmap通常是直接對磁碟的映射——因此不算是共享內存，存儲量非常大，但訪問慢； shmat與此相反，通常將資源保存在內存中創建映射，訪問快，但存儲量較小。
不過要注意一點，操作系統並不保證任何並發問題，例如兩個進程同時更改同一塊內存區域，正如你和你的朋友在線編輯同一個文檔中的同一個標題，這會導致一些不好的結果，所以我們需要藉助信號量或其他方式來完成同步。
信號量是迪傑斯特拉最先提出的一種為解決 同步不同執行線程問題 的一種方法，進程與線程抽象來看大同小異，所以 信號量同樣可以用於同步進程間通信 。
信號量 s 是具有非負整數值的全局變數，由兩種特殊的 原子操作 來實現，這兩種原子操作稱為 P 和 V ：
信號量並不用來傳送資源，而是用來保護共享資源，理解這一點是很重要的，信號量 s 的表示的含義為 同時允許最大訪問資源的進程數量 ，它是一個全局變數。來考慮一個上面簡單的例子：兩個進程同時修改而造成錯誤，我們不考慮讀者而僅僅考慮寫者進程，在這個例子中共享資源最多允許一個進程修改資源，因此我們初始化 s 為1。
開始時，A率先寫入資源，此時A調用P(s)，將 s 減一，此時 s = 0，A進入共享區工作。
此時，進程B也想進入共享區修改資源，它調用P(s)發現此時s為0，於是掛起進程，加入等待隊列。
A工作完畢，調用V(s)，它發現s為0並檢測到等待隊列不為空，於是它隨機喚醒一個等待進程，並將s加1，這里喚醒了B。
B被喚醒，繼續執行P操作，此時s不為0，B成功執行將s置為0並進入工作區。
此時C想要進入工作區......
可以發現，在無論何時只有一個進程能夠訪問共享資源，這就是信號量做的事情，他控制進入共享區的最大進程數量，這取決於初始化s的值。此後，在進入共享區之前調用P操作，出共享區後調用V操作，這就是信號量的思想。
在Linux下並沒有直接的P&V函數，而是需要我們根據這幾個基本的sem函數族進行封裝：
正如其名，管道就如同生活中的一根管道，一端輸送，而另一端接收，雙方不需要知道對方，只需要知道管道就好了。
管道是一種最 基本的進程間通信機制。 管道由pipe函數來創建： 調用pipe函數，會在內核中開辟出一塊緩沖區用來進行進程間通信，這塊緩沖區稱為管道，它有一個讀端和一個寫端。管道被分為匿名管道和有名管道。
匿名管道通過pipe函數創建，這個函數接收一個長度為2的Int數組，並返回1或0表示成功或者失敗：
int pipe(int fd[2])
這個函數打開兩個文件描述符，一個讀端文件，一個寫端，分別存入fd[0]和fd[1]中，然後可以作為參數調用 write 和 read 函數進行寫入或讀取，注意fd[0]只能讀取文件，而fd[1]只能用於寫入文件。
你可能有個疑問，這要怎麼實現通信？其他進程又不知道這個管道，因為進程是獨立的，其他進程看不到某一個進程進行了什麼操作。
是的，『其他』進程確實是不知道，但是它的子進程卻可以！這里涉及到fork派生進程的相關知識，一個進程派生一個子進程，那麼子進程將會復制父進程的內存空間信息，注意這里是復制而不是共享，這意味著父子進程仍然是獨立的，但是在這一時刻，它們所有的信息又是相等的。因此子進程也知道該全局管道，並且也擁有兩個文件描述符與管道掛鉤，所以 匿名管道只能在具有親緣關系的進程間通信。
還要注意，匿名管道內部採用環形隊列實現，只能由寫端到讀端，由於設計技術問題，管道被設計為半雙工的，一方要寫入則必須關閉讀描述符，一方要讀出則必須關閉寫入描述符。因此我們說 管道的消息只能單向傳遞。
注意管道是堵塞的，如何堵塞將依賴於讀寫進程是否關閉文件描述符。如果讀管道，如果讀到空時，假設此時寫埠還沒有被完全關閉，那麼操作系統會假設還有數據要讀，此時讀進程將會被堵塞，直到有新數據或寫埠被關閉；如果管道為空，且寫埠也被關閉，此時操作系統會認為已經沒有東西可讀，會直接退出，並關閉管道。
對於寫一個已經滿了的管道同理而言。
管道內部由內核管理，在半雙工的條件下，保證數據不會出現並發問題。
了解了匿名管道之後，有名管道便很好理解了。在匿名管道的介紹中，我們說其他進程不知道管道和文件描述符的存在，所以匿名管道只適用於具有親緣關系的進程，而命名管道則很好的解決了這個問題 —— 現在管道有一個唯一的名稱了，任何進程都可以訪問這個管道。
注意，操作系統將管道看作一個抽象的文件，但管道並不是普通的文件，管道存在於內核空間中而不放置在磁碟(有名管道文件系統上有一個標識符，沒有數據塊)，訪問速度更快，但存儲量較小，管道是臨時的，是隨進程的，當進程銷毀，所有埠自動關閉，此時管道也是不存在的，操作系統將所有IO抽象的看作文件，例如網路也是一種文件，這意味著我們可以採用任何文件方法操作管道，理解這種抽象是很重要的，命名管道就利用了這種抽象。
Linux下，採用mkfifo函數創建，可以傳入要指定的『文件名』，然後其他進程就可以調用open方法打開這個特殊的文件，並進行write和read操作(那肯定是位元組流對吧)。
注意，命名管道適用於任何進程，除了這一點不同外，其餘大多數都與匿名管道相同。
消息隊列亦稱報文隊列，也叫做信箱，是Linux的一種通信機制，這種通信機制傳遞的數據會被拆分為一個一個獨立的數據塊，也叫做消息體，消息體中可以定義類型與數據，克服了無格式承載位元組流的缺陷(現在收到void*後可以知道其原本的格式惹):
同管道類似，它有一個不足就是每個消息的最大長度是有上限的，整個消息隊列也是長度限制的。
內核為每個IPC對象維護了一個數據結構struct ipc_perm，該數據結構中有指向鏈表頭與鏈表尾部的指針，保證每一次插入取出都是O(1)的時間復雜度。
一個進程可以發送信號給另一個進程，一個信號就是一條消息，可以用於通知一個進程組發送了某種類型的事件，該進程組中的進程可以採取處理程序處理事件。
Linux下 unistd.h 頭文件下定義了如圖中的常量，當你在shell命令行鍵入 ctrl + c 時，內核就會前台進程組的每一個進程發送 SIGINT 信號，中止進程。
我們可以看到上述只有30個信號，因此操作系統會為每一個進程維護一個int類型變數sig，利用其中30位代表是否有對應信號事件，每一個進程還有一個int類型變數block，與sig對應，其30位表示是否堵塞對應信號(不調用處理程序)。如果存在多個相同的信號同時到來，多餘信號會被存儲在一個等待隊列中等待。
我們要理解進程組是什麼，每個進程屬於一個進程組，可以有多個進程屬於同一個組。每個進程擁有一個進程ID，稱為 pid ，而每個進程組擁有一個進程組ID，稱為 pgid ，默認情況下，一個進程與其子進程屬於同一進程組。
軟體方面(諸如檢測鍵盤輸入是硬體方面)可以利用kill函數發送信號，kill函數接受兩個參數，進程ID和信號類型，它將該信號類型發送到對應進程，如果該pid為0，那麼會發送到屬於自身進程組的所有進程。
接收方可以採用signal函數給對應事件添加處理程序，一旦事件發生，如果未被堵塞，則調用該處理程序。
Linux下有一套完善的函數用以處理信號機制。
Socket套接字是用與網路中不同主機的通信方式，多用於客戶端與伺服器之間，在Linux下也有一系列C語言函數，諸如socket、connect、bind、listen與accept，我們無需花太多時間研究這些函數，因為我們可能一輩子都不會與他們打交道，對於原理的學習，後續我會對Java中的套接字socket源碼進行剖析。
對於工作而言，我們可能一輩子都用不上這些操作，但作為對於操作系統的學習，認識到進程間是如何通信還是很有必要的。
面試的時候對於這些方法我們不需要掌握到很深的程度，但我們必須要講的來有什麼通信方式，這些方式都有什麼特點，適用於什麼條件，大致是如何操作的，能說出這些，基本足以讓面試官對你十分滿意了。
G. linux下進程通信 C語言編寫
這個真有點難度,linux下幾乎只有標准C語言,沒有像VC那樣被修改了標準的語言,所以可以認為linux下的C語言都是標準的。 這個程序要是所有的代碼都自己寫的話,會非常復雜的,並且操作系統也不允許你寫這樣的程序...
H. C語言中怎麼用管道和進程實現雙向通信
#include "dpopen.h"
#define MAXLINE 80
int main()
{
char line[MAXLINE];
FILE *fp;
fp = dpopen("sort");
if (fp == NULL) {
perror("dpopen error");
exit(1);
}
fprintf(fp, "orange\n");
fprintf(fp, "apple\n");
fprintf(fp, "pear\n");
if (dphalfclose(fp) < 0) {
perror("dphalfclose error");
exit(1);
}
for (;;) {
if (fgets(line, MAXLINE, fp) == NULL)
break;
fputs(line, stdout);
}
dpclose(fp);
return 0;
}
輸出結果為：
apple
orange
pear