❶ linux 下進程間通過信號進行通信的具體實現過程
kill函數用來發送信號給指定的進程，在Shell下輸入man 2 kill可獲取其函數原型如下：
#include <sys/types.h>
#include <signal.h>
int kill(pid_t pid,int sig);
該函數的行為與第一個參數pid的取值有關，第二個參數sig表示信號編號。
如果pid是正數，則發送信號sig給進程號為pid的進程；
如果pid為0，則發送信號sig給當前進程所屬進程組里的所有進程；
如果pid為－1，則把信號sig廣播至系統內除1號進程（init進程）和自身以外的所有進程；
如果pid是－1還小的負數，則發送信號sig給屬於進程組－pid的所有進程。
如果參數sig是0，則kill()仍執行正常的錯誤檢查，但不發送信號。可以利用這一點來確定某進程是否有權向另外一個進程發送信號。如果向一個並不存在的進程發送空信號，則kill()返回－1，errno則被設置為ESRCH。
函數執行成功返回0，當有錯誤發生時則返回－1，錯誤代碼存入errno中，詳細的錯誤代碼說明請參考man手冊。
注意：只有具有root許可權的進程才能向其他任一進程發送信號，非root許可權的進程只能向屬於同一個組或同一個用戶的進程發送信號。
更簡單的方法是通過進程名給進程發信號。比如你的進程名是 aproc，你自己定義一個信號量18，那麼：
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
char cmd[256]=""; int sig = 18;
char procname[]="aproc";
sprintf(cmd, "killall -%d %s\n", sig, procname);
system(cmd);
就能給特定進程發信號了
充分利用system函數，可以簡化很多編程工作量，比如查IP地址、查硬碟目錄、查磁碟空間等等，編程很麻煩的事都能用system處理，相當於在程序里調用SHELL
❷ 如何在linux環境下實現進程之間的通信
linux環境下實現進程之間的通信主要有以下幾種方式：
# 管道( pipe )：管道是一種半雙工的通信方式，數據只能單向流動，而且只能在具有親緣關系的進程間使用。進程的親緣關系通常是指父子進程關系。
# 有名管道 (named pipe) ： 有名管道也是半雙工的通信方式，但是它允許無親緣關系進程間的通信。
# 信號量( semophore ) ： 信號量是一個計數器，可以用來控制多個進程對共享資源的訪問。它常作為一種鎖機制，防止某進程正在訪問共享資源時，其他進程也訪問該資源。因此，主要作為進程間以及同一進程內不同線程之間的同步手段。
# 消息隊列( message queue ) ： 消息隊列是由消息的鏈表，存放在內核中並由消息隊列標識符標識。消息隊列克服了信號傳遞信息少、管道只能承載無格式位元組流以及緩沖區大小受限等缺點。
# 信號 ( sinal ) ： 信號是一種比較復雜的通信方式，用於通知接收進程某個事件已經發生。
#共享內存( shared memory)：共享內存就是映射一段能被其他進程所訪問的內存，這段共享內存由一個進程創建，但多個進程都可以訪問。共享內存是最快的IPC方式，它是針對其他進程間通信方式運行效率低而專門設計的。它往往與其他通信機制，如信號量，配合使用，來實現進程間的同步和通信。
# 套接字( socket ) ： 套解口也是一種進程間通信機制，與其他通信機制不同的是，它可用於不同及其間的進程通信。
管道的主要局限性正體現在它的特點上：
只支持單向數據流；
只能用於具有親緣關系的進程之間；
沒有名字；
管道的緩沖區是有限的（管道制存在於內存中，在管道創建時，為緩沖區分配一個頁面大小）；
管道所傳送的是無格式位元組流，這就要求管道的讀出方和寫入方必須事先約定好數據的格式，比如多少位元組算作一個消息（或命令、或記錄）等等；
❸ 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在把共享內存區域映射到進程空間時，並不真正改變進程的頁表。當進程第一次訪問內存映射區域訪問時，會因為沒有物理頁表的分配而導致一個缺頁異常，然後內核再根據相應的存儲管理機制為共享內存映射區域分配相應的頁表。
❹ linux：無名管道通信實驗
#include<unistd.h>
#include<stdio.h>
//警告：該程序未做錯誤驗證，未關閉管道（由系統自動關閉）
intmain()
{
intp2c[2];//該管道父進程寫，子進程讀
intc2p[2];//該管道子進程寫，父進程讀
//創建2條管道
pipe(p2c);
pipe(c2p);
intpid=fork();
intfd_read,fd_write;//這兩個描述符用於保存某進程讀端和寫端
intpid_my;//保存某進程自身的pid
intpid_other;//另一進程的pid，通過
if(pid==0){//子進程
fd_read=p2c[0];
fd_write=c2p[1];
//通過getpid取得自身pid，寫到管道里
pid_my=getpid();
write(fd_write,&pid_my,sizeof(int));
//從另一管道讀取另一進程的pid
read(fd_read,&pid_other,sizeof(int));
//列印讀取到的pid
printf("Recivepid:%d ",pid_other);
}else{ //p
fd_read=c2p[0];
fd_write=p2c[1];
pid_my=getpid();
//由於子進程是先寫自身pid，父進程最好先讀取子進程的pid
read(fd_read,&pid_other,sizeof(int));
write(fd_write,&pid_my,sizeof(int));
printf("Recivepid:%d ",pid_other);
}
return0;
}
❺ linux 進程間通信程序設計
我給你回答一下吧，
發送：
#include <sys/msg.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
struct msgbuf
{
long mtype;
char mtext[100];
};
int main()
{
key_t key;
int msgid,err;
char *str="Hello!";
struct msgbuf mymsg_buf,rev_buf;
key=ftok("/test/programs/msg",'a');
mymsg_buf.mtype=1;
msgid=msgget(key,IPC_CREAT|0666);
if(msgid<0)
printf("msgget failed\n");
strcpy(mymsg_buf.mtext,str);
err=msgsnd(msgid,&mymsg_buf,sizeof(mymsg_buf.mtext),IPC_NOWAIT);//必須使用sizeof，不能用strlen()
if(err<0)
printf("msgsnd failed\n");
}
接收：
#include <sys/msg.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
struct msgbuf
{
long mtype;
char mtext[100];
};
int main()
{
key_t key;
int msgid,err;
struct msgbuf mymsg_buf,rev_buf;
key=ftok("/test/programs/msg",'a');
mymsg_buf.mtype=1;
msgid=msgget(key,IPC_CREAT|0666);
if(msgid<0)
printf("msgget failed\n");
err=msgrcv(msgid,&rev_buf,sizeof(rev_buf.mtext),1,IPC_NOWAIT);
if(err<0)printf("msgrev failed\n");
else printf("I have recevied : %s\n",rev_buf.mtext);
}
❻ Linux進程間通信（互斥鎖、條件變數、讀寫鎖、文件鎖、信號燈）
為了能夠有效的控制多個進程之間的溝通過程，保證溝通過程的有序和和諧，OS必須提供一定的同步機制保證進程之間不會自說自話而是有效的協同工作。比如在 共享內存的通信方式中，兩個或者多個進程都要對共享的內存進行數據寫入，那麼怎麼才能保證一個進程在寫入的過程中不被其它的進程打斷，保證數據的完整性 呢？又怎麼保證讀取進程在讀取數據的過程中數據不會變動，保證讀取出的數據是完整有效的呢？
常用的同步方式有： 互斥鎖、條件變數、讀寫鎖、記錄鎖(文件鎖)和信號燈.
互斥鎖：
顧名思義，鎖是用來鎖住某種東西的，鎖住之後只有有鑰匙的人才能對鎖住的東西擁有控制權(把鎖砸了，把東西偷走的小偷不在我們的討論范圍了)。所謂互斥， 從字面上理解就是互相排斥。因此互斥鎖從字面上理解就是一點進程擁有了這個鎖，它將排斥其它所有的進程訪問被鎖住的東西，其它的進程如果需要鎖就只能等待，等待擁有鎖的進程把鎖打開後才能繼續運行。 在實現中，鎖並不是與某個具體的變數進行關聯，它本身是一個獨立的對象。進(線)程在有需要的時候獲得此對象，用完不需要時就釋放掉。
互斥鎖的主要特點是互斥鎖的釋放必須由上鎖的進(線)程釋放，如果擁有鎖的進(線)程不釋放，那麼其它的進(線)程永遠也沒有機會獲得所需要的互斥鎖。
互斥鎖主要用於線程之間的同步。
條件變數：
上文中提到，對於互斥鎖而言，如果擁有鎖的進(線)程不釋放鎖，其它進(線)程永遠沒機會獲得鎖，也就永遠沒有機會繼續執行後續的邏輯。在實際環境下，一 個線程A需要改變一個共享變數X的值，為了保證在修改的過程中X不會被其它的線程修改，線程A必須首先獲得對X的鎖。現在假如A已經獲得鎖了，由於業務邏 輯的需要，只有當X的值小於0時，線程A才能執行後續的邏輯，於是線程A必須把互斥鎖釋放掉，然後繼續「忙等」。如下面的偽代碼所示：
1.// get x lock
2.while(x
❼ Linux下進程的創建與進程間通信
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
int main()
{
int fd[2], pid, len;
char inpipe[100], outpipe[100];
pipe(fd);
pid = fork();
if (pid == 0)
{
/* first child */
close(fd[0]);
strcpy(outpipe, "The first child process is sending message!");
lockf(fd[1], 1, 0);
write(fd[1], outpipe, 100);
lockf(fd[1], 0, 0);
exit(0);
}
pid = fork();
if (pid == 0)
{
/* 2nd child */
close(fd[0]);
strcpy(outpipe, "The second child process is sending message!");
lockf(fd[1], 1, 0);
write(fd[1], outpipe, 100);
lockf(fd[1], 0, 0);
exit(0);
}
/* parent */
close(fd[1]);
len = read(fd[0], inpipe, 100);
printf("RECV: %s\n", inpipe);
len = read(fd[0], inpipe, 100);
printf("RECV: %s\n", inpipe);
wait(NULL);
wait(NULL);
return 0;
}
❽ linux進程間通信實驗(管道)求源代碼
到CSDN或PSDN去找吧。
比如：
unix環境高級編程源碼
www.pudn.com/downloads190/sourcecode/unix_linux/detail891285.html
❾ 一個Linux多進程編程
1 引言
對於沒有接觸過Unix/Linux操作系統的人來說，fork是最難理解的概念之一：它執行一次卻返回兩個值。fork函數是Unix系統最傑出的成就之一，它是七十年代UNIX早期的開發者經過長期在理論和實踐上的艱苦探索後取得的成果，一方面，它使操作系統在進程管理上付出了最小的代價，另一方面，又為程序員提供了一個簡潔明了的多進程方法。與DOS和早期的Windows不同，Unix/Linux系統是真正實現多任務操作的系統，可以說，不使用多進程編程，就不能算是真正的Linux環境下編程。
多線程程序設計的概念早在六十年代就被提出，但直到八十年代中期，Unix系統中才引入多線程機制，如今，由於自身的許多優點，多線程編程已經得到了廣泛的應用。
下面，我們將介紹在Linux下編寫多進程和多線程程序的一些初步知識。
2 多進程編程
什麼是一個進程？進程這個概念是針對系統而不是針對用戶的，對用戶來說，他面對的概念是程序。當用戶敲入命令執行一個程序的時候，對系統而言，它將啟動一個進程。但和程序不同的是，在這個進程中，系統可能需要再啟動一個或多個進程來完成獨立的多個任務。多進程編程的主要內容包括進程式控制制和進程間通信，在了解這些之前，我們先要簡單知道進程的結構。
2.1 Linux下進程的結構
Linux下一個進程在內存里有三部分的數據，就是"代碼段"、"堆棧段"和"數據段"。其實學過匯編語言的人一定知道，一般的CPU都有上述三種段寄存器，以方便操作系統的運行。這三個部分也是構成一個完整的執行序列的必要的部分。
"代碼段"，顧名思義，就是存放了程序代碼的數據，假如機器中有數個進程運行相同的一個程序，那麼它們就可以使用相同的代碼段。"堆棧段"存放的就是子程序的返回地址、子程序的參數以及程序的局部變數。而數據段則存放程序的全局變數，常數以及動態數據分配的數據空間（比如用malloc之類的函數取得的空間）。這其中有許多細節問題，這里限於篇幅就不多介紹了。系統如果同時運行數個相同的程序，它們之間就不能使用同一個堆棧段和數據段。
2.2 Linux下的進程式控制制
在傳統的Unix環境下，有兩個基本的操作用於創建和修改進程：函數fork( )用來創建一個新的進程，該進程幾乎是當前進程的一個完全拷貝；函數族exec( )用來啟動另外的進程以取代當前運行的進程。Linux的進程式控制制和傳統的Unix進程式控制制基本一致，只在一些細節的地方有些區別，例如在Linux系統中調用vfork和fork完全相同，而在有些版本的Unix系統中，vfork調用有不同的功能。由於這些差別幾乎不影響我們大多數的編程，在這里我們不予考慮。
2.2.1 fork( )
fork在英文中是"分叉"的意思。為什麼取這個名字呢？因為一個進程在運行中，如果使用了fork，就產生了另一個進程，於是進程就"分叉"了，所以這個名字取得很形象。下面就看看如何具體使用fork，這段程序演示了使用fork的基本框架：
void main(){
int i;
if ( fork() == 0 ) {
/* 子進程程序 */
for ( i = 1; i <1000; i ++ ) printf("This is child process\n");
}
else {
/* 父進程程序*/
for ( i = 1; i <1000; i ++ ) printf("This is process process\n");
}
}
程序運行後，你就能看到屏幕上交替出現子進程與父進程各列印出的一千條信息了。如果程序還在運行中，你用ps命令就能看到系統中有兩個它在運行了。
那麼調用這個fork函數時發生了什麼呢？fork函數啟動一個新的進程，前面我們說過，這個進程幾乎是當前進程的一個拷貝：子進程和父進程使用相同的代碼段；子進程復制父進程的堆棧段和數據段。這樣，父進程的所有數據都可以留給子進程，但是，子進程一旦開始運行，雖然它繼承了父進程的一切數據，但實際上數據卻已經分開，相互之間不再有影響了，也就是說，它們之間不再共享任何數據了。它們再要交互信息時，只有通過進程間通信來實現，這將是我們下面的內容。既然它們如此相象，系統如何來區分它們呢？這是由函數的返回值來決定的。對於父進程，fork函數返回了子程序的進程號，而對於子程序，fork函數則返回零。在操作系統中，我們用ps函數就可以看到不同的進程號，對父進程而言，它的進程號是由比它更低層的系統調用賦予的，而對於子進程而言，它的進程號即是fork函數對父進程的返回值。在程序設計中，父進程和子進程都要調用函數fork（）下面的代碼，而我們就是利用fork（）函數對父子進程的不同返回值用if...else...語句來實現讓父子進程完成不同的功能，正如我們上面舉的例子一樣。我們看到，上面例子執行時兩條信息是交互無規則的列印出來的，這是父子進程獨立執行的結果，雖然我們的代碼似乎和串列的代碼沒有什麼區別。
讀者也許會問，如果一個大程序在運行中，它的數據段和堆棧都很大，一次fork就要復制一次，那麼fork的系統開銷不是很大嗎？其實UNIX自有其解決的辦法，大家知道，一般CPU都是以"頁"為單位來分配內存空間的，每一個頁都是實際物理內存的一個映像，象INTEL的CPU，其一頁在通常情況下是4086位元組大小，而無論是數據段還是堆棧段都是由許多"頁"構成的，fork函數復制這兩個段，只是"邏輯"上的，並非"物理"上的，也就是說，實際執行fork時，物理空間上兩個進程的數據段和堆棧段都還是共享著的，當有一個進程寫了某個數據時，這時兩個進程之間的數據才有了區別，系統就將有區別的"頁"從物理上也分開。系統在空間上的開銷就可以達到最小。
下面演示一個足以"搞死"Linux的小程序，其源代碼非常簡單：
void main()
{
for( ; ; ) fork();
}
這個程序什麼也不做，就是死循環地fork，其結果是程序不斷產生進程，而這些進程又不斷產生新的進程，很快，系統的進程就滿了，系統就被這么多不斷產生的進程"撐死了"。當然只要系統管理員預先給每個用戶設置可運行的最大進程數，這個惡意的程序就完成不了企圖了。
2.2.2 exec( )函數族
下面我們來看看一個進程如何來啟動另一個程序的執行。在Linux中要使用exec函數族。系統調用execve（）對當前進程進行替換，替換者為一個指定的程序，其參數包括文件名（filename）、參數列表（argv）以及環境變數（envp）。exec函數族當然不止一個，但它們大致相同，在Linux中，它們分別是：execl，execlp，execle，execv，execve和execvp，下面我只以execlp為例，其它函數究竟與execlp有何區別，請通過manexec命令來了解它們的具體情況。
一個進程一旦調用exec類函數，它本身就"死亡"了，系統把代碼段替換成新的程序的代碼，廢棄原有的數據段和堆棧段，並為新程序分配新的數據段與堆棧段，唯一留下的，就是進程號，也就是說，對系統而言，還是同一個進程，不過已經是另一個程序了。（不過exec類函數中有的還允許繼承環境變數之類的信息。）
那麼如果我的程序想啟動另一程序的執行但自己仍想繼續運行的話，怎麼辦呢？那就是結合fork與exec的使用。下面一段代碼顯示如何啟動運行其它程序：
char command[256];
void main()
{
int rtn; /*子進程的返回數值*/
while(1) {
/* 從終端讀取要執行的命令 */
printf( ">" );
fgets( command, 256, stdin );
command[strlen(command)-1] = 0;
if ( fork() == 0 ) {
/* 子進程執行此命令 */
execlp( command, command );
/* 如果exec函數返回，表明沒有正常執行命令，列印錯誤信息*/
perror( command );
exit( errorno );
}
else {
/* 父進程， 等待子進程結束，並列印子進程的返回值 */
wait ( &rtn );
printf( " child process return %d\n",. rtn );
}
}
}
此程序從終端讀入命令並執行之，執行完成後，父進程繼續等待從終端讀入命令。熟悉DOS和WINDOWS系統調用的朋友一定知道DOS/WINDOWS也有exec類函數，其使用方法是類似的，但DOS/WINDOWS還有spawn類函數，因為DOS是單任務的系統，它只能將"父進程"駐留在機器內再執行"子進程"，這就是spawn類的函數。WIN32已經是多任務的系統了，但還保留了spawn類函數，WIN32中實現spawn函數的方法同前述UNIX中的方法差不多，開設子進程後父進程等待子進程結束後才繼續運行。UNIX在其一開始就是多任務的系統，所以從核心角度上講不需要spawn類函數。
在這一節里，我們還要講講system（）和popen（）函數。system（）函數先調用fork（），然後再調用exec（）來執行用戶的登錄shell，通過它來查找可執行文件的命令並分析參數，最後它么使用wait（）函數族之一來等待子進程的結束。函數popen（）和函數system（）相似，不同的是它調用pipe（）函數創建一個管道，通過它來完成程序的標准輸入和標准輸出。這兩個函數是為那些不太勤快的程序員設計的，在效率和安全方面都有相當的缺陷，在可能的情況下，應該盡量避免。
2.3 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 消息隊列
消息隊列用於運行於同一台機器上的進程間通信，它和管道很相似，事實上，它是一種正逐漸被淘汰的通信方式，我們可以用流管道或者套介面的方式來取代它，所以，我們對此方式也不再解釋，也建議讀者忽略這種方式。
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等來實現。
❿ linux進程間通信（消息隊列）
在與此進程P1通信的進來程P2中，同源樣的以ftok創建KEY, msgget在該KEY上創建消息隊列，
只需要保證，ftok的參數中，第一個參數，即文件，是同一個文件即可。當P2中的文件與P1不同時，msgget函數將會返回錯誤。
可以說，消息隊列也是通過文件實現的，就像創建一個socket，要使用它時，也已經為其綁定了一個文件fd。
有一個例子不錯，你可以看看。實驗時，需要把ftok的第一個參數，即文件，設置為一個你當前目錄存在的文件。你可以touch一個臨時文件來實驗。
http://blog.csdn.net/lcrystal623/archive/2007/03/16/1531183.aspx
同時，謝謝link的博主。