linux作業系統下c語言程式設計入門(2)(轉)[@more@]4)程式設計入門--時間概念
前言:Linux下的時間概念
這一章我們學習Linux的時間表示和計算函式
時間的表示
時間的測量
計時器的使用
1。時間表示在程式當中,我們經常要輸出系統當前的時間,比如我們使用date命令
的輸出結果.這個時候我們可以使用下面兩個函式
#include

time_t time(time_t *tloc);
char *ctime(const time_t *clock);
time函式返回從1970年1月1日0點以來的秒數.儲存在time_t結構之中.不過這個函式的返
回值對於我們來說沒有什麼實際意義.這個時候我們使用第二個函式將秒數轉化為字串
.. 這個函式的返回型別是固定的:一個可能值為. Thu Dec 7 14:58:59 2000 這個字串
的長度是固定的為26
2。時間的測量有時候我們要計算程式執行的時間.比如我們要對演算法進行時間分析
..這個時候可以使用下面這個函式.
#include

int gettimeofday(struct timeval *tv,struct timezone *tz);
strut timeval {
long tv_sec; /* 秒數 */
long tv_usec; /* 微秒數 */
};
gettimeofday將時間儲存在結構tv之中.tz一般我們使用NULL來代替.
#include #include #include

void function()
{
unsigned int i,j;
double y;
for(i=0;i<1000;i++)
for(j=0;j<1000;j++)
y=sin((double)i);
}
main()
{
struct timeval tpstart,tpend;
float timeuse;
gettimeofday(&tpstart,NULL);
function();
gettimeofday(&tpend,NULL);
timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+
tpend.tv_usec-tpstart.tv_usec;
timeuse/=1000000;
printf("Used Time:%f ",timeuse);
exit(0);
}
這個程式輸出函式的執行時間,我們可以使用這個來進行系統效能的測試,或者是函式算
法的效率分析.在我機器上的一個輸出結果是: Used Time:0.556070
3。計時器的使用 Linux作業系統為每一個程式提供了3個內部間隔計時器.
ITIMER_REAL:減少實際時間.到時的時候發出SIGALRM訊號.
ITIMER_VIRTUAL:減少有效時間(程式執行的時間).產生SIGVTALRM訊號.
ITIMER_PROF:減少程式的有效時間和系統時間(為程式排程用的時間).這個經常和上面一
個使用用來計算系統核心時間和使用者時間.產生SIGPROF訊號.
具體的操作函式是:
#include
int getitimer(int which,struct itimerval *value);
int setitimer(int which,struct itimerval *newval,
struct itimerval *oldval);
struct itimerval {
struct timeval it_interval;
struct timeval it_value;
}
getitimer函式得到間隔計時器的時間值.儲存在value中 setitimer函式設定間隔計時器
的時間值為newval.並將舊值儲存在oldval中. which表示使用三個計時器中的哪一個.
itimerval結構中的it_value是減少的時間,當這個值為0的時候就發出相應的訊號了. 然
後設定為it_interval值.
#include
#include
#include
#include
#include
#define PROMPT "時間已經過去了兩秒鐘 a"
char *prompt=PROMPT;
unsigned int len;
void prompt_info(int signo)
{
write(STDERR_FILENO,prompt,len);
}
void init_sigaction(void)
{
struct sigaction act;
act.sa_handler=prompt_info;
act.sa_flags=0;
sigemptyset(&act.sa_mask);
sigaction(SIGPROF,&act,NULL);
}
void init_time()
{
struct itimerval value;
value.it_value.tv_sec=2;
value.it_value.tv_usec=0;
value.it_interval=value.it_value;
setitimer(ITIMER_PROF,&value,NULL);
}
int main()
{
len=strlen(prompt);
init_sigaction();
init_time();
while(1);
exit(0);
}
這個程式每執行兩秒中之後會輸出一個提示.

5)Linux程式設計入門--訊號處理
Linux下的訊號事件
前言:這一章我們討論一下Linux下的訊號處理函式.
Linux下的訊號處理函式:
訊號的產生
訊號的處理
其它訊號函式
一個例項
1。訊號的產生
Linux下的訊號可以類比於DOS下的INT或者是Windows下的事件.在有一個訊號發生時
候相信的訊號就會傳送給相應的程式.在Linux下的訊號有以下幾個. 我們使用 kill -l
命令可以得到以下的輸出結果:
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE
9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
13) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD
18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN
22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ
26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO
30) SIGPWR
關於這些訊號的詳細解釋請檢視man 7 signal的輸出結果. 訊號事件的發生有兩個來源
:一個是硬體的原因(比如我們按下了鍵盤),一個是軟體的原因(比如我們使用系統函式或
者是命令發出訊號). 最常用的四個發出訊號的系統函式是kill, raise, alarm和setit
imer函式. setitimer函式我們在計時器的使用那一章再學習.
#include
#include
#include
int kill(pid_t pid,int sig);
int raise(int sig);
unisigned int alarm(unsigned int seconds);
kill系統呼叫負責向程式傳送訊號sig.
如果pid是正數,那麼向訊號sig被髮送到程式pid.
如果pid等於0,那麼訊號sig被髮送到所以和pid程式在同一個程式組的程式
如果pid等於-1,那麼訊號發給所有的程式表中的程式,除了最大的哪個程式號.
如果pid由於-1,和0一樣,只是傳送程式組是-pid.
我們用最多的是第一個情況.還記得我們在守護程式那一節的例子嗎?我們那個時候用這
個函式殺死了父程式守護程式的建立
raise系統呼叫向自己傳送一個sig訊號.我們可以用上面那個函式來實現這個功能的.
alarm函式和時間有點關係了,這個函式可以在seconds秒後向自己傳送一個SIGALRM訊號
.. 下面這個函式會有什麼結果呢?
#include
main()
{
unsigned int i;
alarm(1);
for(i=0;1;i++)
printf("I=%d",i);
}
SIGALRM的預設操作是結束程式,所以程式在1秒之後結束,你可以看看你的最後I值為多少
,來比較一下大家的系統效能差異(我的是2232).
2。訊號操作有時候我們希望程式正確的執行,而不想程式受到訊號的影響,比如我
們希望上面那個程式在1秒鐘之後不結束.這個時候我們就要進行訊號的操作了.
訊號操作最常用的方法是訊號遮蔽.訊號遮蔽要用到下面的幾個函式.
#include
int sigemptyset(sigset_t *set);
int sigfillset(sigset_t *set);
int sigaddset(sigset_t *set,int signo);
int sigdelset(sigset_t *set,int signo);
int sigismember(sigset_t *set,int signo);
int sigprocmask(int how,const sigset_t *set,sigset_t *oset);
sigemptyset函式初始化訊號集合set,將set設定為空.sigfillset也初始化訊號集合,只
是將訊號集合設定為所有訊號的集合.sigaddset將訊號signo加入到訊號集合之中,sigd
elset將訊號從訊號集合中刪除.sigismember查詢訊號是否在訊號集合之中.
sigprocmask是最為關鍵的一個函式.在使用之前要先設定好訊號集合set.這個函式的作
用是將指定的訊號集合set加入到程式的訊號阻塞集合之中去,如果提供了oset那麼當前
的程式訊號阻塞集合將會儲存在oset裡面.引數how決定函式的操作方式.
SIG_BLOCK:增加一個訊號集合到當前程式的阻塞集合之中.
SIG_UNBLOCK:從當前的阻塞集合之中刪除一個訊號集合.
SIG_SETMASK:將當前的訊號集合設定為訊號阻塞集合.
以一個例項來解釋使用這幾個函式.
#include
#include
#include

#include int main(int argc,char **argv) { double y; sigset_t intmask; int i,repeat_factor; if(argc!=2) { fprintf(stderr,"Usage:%s repeat_factor
a",argv[0]); exit(1); } if((repeat_factor=atoi(argv[1]))<1)repeat_factor=10; sigemptyset(&intmask); /* 將訊號集合設定為空 */ sigaddset(&intmask,SIGINT); /* 加入中斷 Ctrl+C 訊號*/ while(1) { /*阻塞訊號,我們不希望儲存原來的集合所以引數為NULL*/ sigprocmask(SIG_BLOCK,&intmask,NULL); fprintf(stderr,"SIGINT signal blocked
"); for(i=0;i fprintf(stderr,"Blocked calculation is finished
"); /* 取消阻塞 */ sigprocmask(SIG_UNBLOCK,&intmask,NULL); fprintf(stderr,"SIGINT signal unblocked
"); for(i=0;i fprintf(stderr,"Unblocked calculation is finished
"); } exit(0); } 程式在執行的時候我們要使用Ctrl+C來結束.如果我們在第一計算的時候發出SIGINT訊號 ,由於訊號已經遮蔽了,所以程式沒有反映.只有到訊號被取消阻塞的時候程式才會結束. 注意我們只要發出一次SIGINT訊號就可以了,因為訊號遮蔽只是將訊號加入到訊號阻塞 集合之中,並沒有丟棄這個訊號.一旦訊號遮蔽取消了,這個訊號就會發生作用. 有時候我們希望對訊號作出及時的反映的,比如當擁護按下Ctrl+C時,我們不想什麼事情 也不做,我們想告訴使用者你的這個操作不好,請不要重試,而不是什麼反映也沒有的. 這個 時候我們要用到sigaction函式. #include int sigaction(int signo,const struct sigaction *act, struct sigaction *oact); struct sigaction { void (*sa_handler)(int signo); void (*sa_sigaction)(int siginfo_t *info,void *act); sigset_t sa_mask; int sa_flags; void (*sa_restore)(void); } 這個函式和結構看起來是不是有點恐怖呢.不要被這個嚇著了,其實這個函式的使用相當 簡單的.我們先解釋一下各個引數的含義. signo很簡單就是我們要處理的訊號了,可以是 任何的合法的訊號.有兩個訊號不能夠使用(SIGKILL和SIGSTOP). act包含我們要對這個 訊號進行如何處理的資訊.oact更簡單了就是以前對這個函式的處理資訊了,主要用來保 存資訊的,一般用NULL就OK了. 訊號結構有點複雜.不要緊我們慢慢的學習. sa_handler是一個函式型指標,這個指標指向一個函式,這個函式有一個引數.這個函式就 是我們要進行的訊號操作的函式. sa_sigaction,sa_restore和sa_handler差不多的,只 是引數不同罷了.這兩個元素我們很少使用,就不管了. sa_flags用來設定訊號操作的各個情況.一般設定為0好了.sa_mask我們已經學習過了 在使用的時候我們用sa_handler指向我們的一個訊號操作函式,就可以了.sa_handler有 兩個特殊的值:SIG_DEL和SIG_IGN.SIG_DEL是使用預設的訊號操作函式,而SIG_IGN是使用 忽略該訊號的操作函式. 這個函式複雜,我們使用一個例項來說明.下面這個函式可以捕捉使用者的CTRL+C訊號.並輸 出一個提示語句. #include #include #include #include #include #define PROMPT "你想終止程式嗎?" char *prompt=PROMPT; void ctrl_c_op(int signo) { write(STDERR_FILENO,prompt,strlen(prompt)); } int main() { struct sigaction act; act.sa_handler=ctrl_c_op; sigemptyset(&act.sa_mask); act.sa_flags=0; if(sigaction(SIGINT,&act,NULL)<0) { fprintf(stderr,"Install Signal Action Error:%s
a",strerror(errno)); exit(1); } while(1); } 在上面程式的訊號操作函式之中,我們使用了write函式而沒有使用fprintf函式.是因為 我們要考慮到下面這種情況.如果我們在訊號操作的時候又有一個訊號發生,那麼程式該 如何執行呢? 為了處理在訊號處理函式執行的時候訊號的發生,我們需要設定sa_mask成 員. 我們將我們要遮蔽的訊號新增到sa_mask結構當中去,這樣這些函式在訊號處理的時 候就會被遮蔽掉的. 3。其它訊號函式 由於訊號的操作和處理比較複雜,我們再介紹幾個訊號操作函式. #include #include int pause(void); int sigsuspend(const sigset_t *sigmask); pause函式很簡單,就是掛起程式直到一個訊號發生了.而sigsuspend也是掛起程式只是在 呼叫的時候用sigmask取代當前的訊號阻塞集合. #include int sigsetjmp(sigjmp_buf env,int val); void siglongjmp(sigjmp_buf env,int val); 還記得goto函式或者是setjmp和longjmp函式嗎.這兩個訊號跳轉函式也可以實現程式的 跳轉讓我們可以從函式之中跳轉到我們需要的地方. 由於上面幾個函式,我們很少遇到,所以只是說明了一下,詳細情況請檢視聯機幫助. 4。一個例項 還記得我們在守護程式建立的哪個程式嗎?守護程式在這裡我們把那個 程式加強一下. 下面這個程式會在也可以檢查使用者的郵件.不過提供了一個開關,如果用 戶不想程式提示有新的郵件到來,可以向程式傳送SIGUSR2訊號,如果想程式提供提示可以 傳送SIGUSR1訊號. #include #include #include #include #include #include #include #include #include /* Linux 的默任個人的郵箱地址是 /var/spool/mail/ */ #define MAIL_DIR "/var/spool/mail/" /* 睡眠10秒鐘 */ #define SLEEP_TIME 10 #define MAX_FILENAME 255 unsigned char notifyflag=1; long get_file_size(const char *filename) { struct stat buf; if(stat(filename,&;buf)==-1) { if(errno==ENOENT)return 0; else return -1; } return (long)buf.st_size; } void send_mail_notify(void) { fprintf(stderr,"New mail has arrived07
"); } void turn_on_notify(int signo) { notifyflag=1; } void turn_off_notify(int signo) { notifyflag=0; } int check_mail(const char *filename) { long old_mail_size,new_mail_size; sigset_t blockset,emptyset; sigemptyset(&;blockset); sigemptyset(&;emptyset); sigaddset(&;blockset,SIGUSR1); sigaddset(&;blockset,SIGUSR2); old_mail_size=get_file_size(filename); if(old_mail_size<0)return 1; if(old_mail_size>0) send_mail_notify(); sleep(SLEEP_TIME); while(1) { if(sigprocmask(SIG_BLOCK,&;blockset,NULL)<0) return 1; while(notifyflag==0)sigsuspend(&;emptyset); if(sigprocmask(SIG_SETMASK,&;emptyset,NULL)<0) return 1; new_mail_size=get_file_size(filename); if(new_mail_size>old_mail_size)send_mail_notify; old_mail_size=new_mail_size; sleep(SLEEP_TIME); } } int main(void) { char mailfile[MAX_FILENAME]; struct sigaction newact; struct passwd *pw; if((pw=getpwuid(getuid()))==NULL) { fprintf(stderr,"Get Login Name Error:%s
a",strerror(errno)); exit(1); } strcpy(mailfile,MAIL_DIR); strcat(mailfile,pw->pw_name); newact.sa_handler=turn_on_notify; newact.sa_flags=0; sigemptyset(&;newact.sa_mask); sigaddset(&;newact.sa_mask,SIGUSR1); sigaddset(&;newact.sa_mask,SIGUSR2); if(sigaction(SIGUSR1,&;newact,NULL)<0) fprintf(stderr,"Turn On Error:%s
a",strerror(errno)); newact.sa_handler=turn_off_notify; if(sigaction(SIGUSR1,&;newact,NULL)<0) fprintf(stderr,"Turn Off Error:%s
a",strerror(errno)); check_mail(mailfile); exit(0); } 訊號操作是一件非常複雜的事情,比我們想象之中的複雜程度還要複雜,如果你想徹底的 弄清楚訊號操作的各個問題,那麼除了大量的練習以外還要多看聯機手冊.不過如果我們 只是一般的使用的話,有了上面的幾個函式也就差不多了. 我們就介紹到這裡了. 6)Linux程式設計入門--訊息管理 前言:Linux下的程式通訊(IPC) Linux下的程式通訊(IPC) POSIX無名訊號量 System V訊號量 System V訊息佇列 System V共享記憶體 1。POSIX無名訊號量 如果你學習過作業系統,那麼肯定熟悉PV操作了.PV操作是原子 操作.也就是操作是不可以中斷的,在一定的時間內,只能夠有一個程式的程式碼在CPU上面 執行.在系統當中,有時候為了順利的使用和保護共享資源,大家提出了訊號的概念. 假設 我們要使用一臺印表機,如果在同一時刻有兩個程式在向印表機輸出,那麼最終的結果會 是什麼呢.為了處理這種情況,POSIX標準提出了有名訊號量和無名訊號量的概念,由於Li nux只實現了無名訊號量,我們在這裡就只是介紹無名訊號量了. 訊號量的使用主要是用 來保護共享資源,使的資源在一個時刻只有一個程式所擁有.為此我們可以使用一個訊號 燈.當訊號燈的值為某個值的時候,就表明此時資源不可以使用.否則就表>示可以使用. 為了提供效率,系統提供了下面幾個函式 POSIX的無名訊號量的函式有以下幾個: #include int sem_init(sem_t *sem,int pshared,unsigned int value); int sem_destroy(sem_t *sem); int sem_wait(sem_t *sem); int sem_trywait(sem_t *sem); int sem_post(sem_t *sem); int sem_getvalue(sem_t *sem); sem_init建立一個訊號燈,並初始化其值為value.pshared決定了訊號量能否在幾個程式 間共享.由於目前Linux還沒有實現程式間共享訊號燈,所以這個值只能夠取0. sem_dest roy是用來刪除訊號燈的.sem_wait呼叫將阻塞程式,直到訊號燈的值大於0.這個函式返回 的時候自動的將訊號燈的值的件一.sem_post和sem_wait相反,是將訊號燈的內容加一同 時發出訊號喚醒等待的程式..sem_trywait和sem_wait相同,不過不阻塞的,當訊號燈的值 為0的時候返回EAGAIN,表示以後重試.sem_getvalue得到訊號燈的值. 由於Linux不支援,我們沒有辦法用源程式解釋了. 這幾個函式的使用相當簡單的.比如我們有一個程式要向一個系統印表機列印兩頁.我們 首先建立一個訊號燈,並使其初始值為1,表示我們有一個資源可用.然後一個程式呼叫se m_wait由於這個時候訊號燈的值為1,所以這個函式返回,印表機開始列印了,同時訊號燈 的值為0 了. 如果第二個程式要列印,呼叫sem_wait時候,由於訊號燈的值為0,資源不可 用,於是被阻塞了.當第一個程式列印完成以後,呼叫sem_post訊號燈的值為1了,這個時候 系統通知第二個程式,於是第二個程式的sem_wait返回.第二個程式開始列印了. 不過我們可以使用執行緒來解決這個問題的.我們會在後面解釋什麼是執行緒的.編譯包含上 面這幾個函式的程式要加上 -lrt選賢,以連線librt.so庫 2。System V訊號量 為了解決上面哪個問題,我們也可以使用System V訊號量.很幸運的 是Linux實現了System V訊號量.這樣我們就可以用例項來解釋了. System V訊號量的函 數主要有下面幾個. #include #include #include key_t ftok(char *pathname,char proj); int semget(key_t key,int nsems,int semflg); int semctl(int semid,int semnum,int cmd,union semun arg); int semop(int semid,struct sembuf *spos,int nspos); struct sembuf { short sem_num; /* 使用那一個訊號 */ short sem_op; /* 進行什麼操作 */ short sem_flg; /* 操作的標誌 */ }; ftok函式是根據pathname和proj來建立一個關鍵字.semget建立一個訊號量.成功時返回 訊號的ID,key是一個關鍵字,可以是用ftok建立的也可以是IPC_PRIVATE表明由系統選用 一個關鍵字. nsems表明我們建立的訊號個數.semflg是建立的許可權標誌,和我們建立一個 檔案的標誌相同. semctl對訊號量進行一系列的控制.semid是要操作的訊號標誌,semnum是訊號的個數,cm d是操作的命令.經常用的兩個值是:SETVAL(設定訊號量的值)和IPC_RMID(刪除訊號燈). arg是一個給cmd的引數. semop是對訊號進行操作的函式.semid是訊號標誌,spos是一個運算元組表明要進行什麼 操作,nspos表明陣列的個數. 如果sem_op大於0,那麼操作將sem_op加入到訊號量的值中 ,並喚醒等待訊號增加的程式. 如果為0,當訊號量的值是0的時候,函式返回,否則阻塞直 到訊號量的值為0. 如果小於0,函式判斷訊號量的值加上這個負值.如果結果為0喚醒等待 訊號量為0的程式,如果小與0函式阻塞.如果大於0,那麼從訊號量裡面減去這個值並返回 .. 下面我們一以一個例項來說明這幾個函式的使用方法.這個程式用標準錯誤輸出來代替我 們用的印表機. #include #include #include #include #include #include #include #include #include #include #define PERMS S_IRUSR|S_IWUSR void init_semaphore_struct(struct sembuf *sem,int semnum, int semop,int semflg) { /* 初始話訊號燈結構 */ sem->sem_num=semnum; sem->sem_op=semop; sem->sem_flg=semflg; } int del_semaphore(int semid) { /* 訊號燈並不隨程式的結束而被刪除,如果我們沒刪除的話(將1改為0) 可以用ipcs命令檢視到訊號燈,用ipcrm可以刪除訊號燈的 */ #if 1 return semctl(semid,0,IPC_RMID); #endif } int main(int argc,char **argv) { char buffer[MAX_CANON],*c; int i,n; int semid,semop_ret,status; pid_t childpid; struct sembuf semwait,semsignal; if((argc!=2)||((n=atoi(argv[1]))<1)) { fprintf(stderr,"Usage:%s number
a",argv[0]); exit(1); } /* 使用IPC_PRIVATE 表示由系統選擇一個關鍵字來建立 */ /* 建立以後訊號燈的初始值為0 */ if((semid=semget(IPC_PRIVATE,1,PERMS))==-1) { fprintf(stderr,"[%d]:Acess Semaphore Error:%s
a", getpid(),strerror(errno)); exit(1); } /* semwait是要求資源的操作(-1) */ init_semaphore_struct(&semwait,0,-1,0); /* semsignal是釋放資源的操作(+1) */ init_semaphore_struct(&semsignal,0,1,0); /* 開始的時候有一個系統資源(一個標準錯誤輸出) */ if(semop(semid,&semsignal,1)==-1) { fprintf(stderr,"[%d]:Increment Semaphore Error:%s
a", getpid(),strerror(errno)); if(del_semaphore(semid)==-1) fprintf(stderr,"[%d]:Destroy Semaphore Error:%s
a", getpid(),strerror(errno)); exit(1); } /* 建立一個程式鏈 */ for(i=0;i if(childpid=fork()) break; sprintf(buffer,"[i=%d]--&gt[Process=%d]--&gt[Parent=%d]--&gt[Child=%d]
", i,getpid(),getppid(),childpid); c=buffer; /* 這裡要求資源,進入原子操作 */ while(((semop_ret=semop(semid,&semwait,1))==-1)&&(errno==EINTR)); if(semop_ret==-1) { fprintf(stderr,"[%d]:Decrement Semaphore Error:%s
a", getpid(),strerror(errno)); } else { while(*c!='')fputc(*c++,stderr); /* 原子操作完成,趕快釋放資源 */ while(((semop_ret=semop(semid,&semsignal,1))==-1)&&(errno==EINTR)); if(semop_ret==-1) fprintf(stderr,"[%d]:Increment Semaphore Error:%s
a", getpid(),strerror(errno)); } /* 不能夠在其他程式反問訊號燈的時候,我們刪除了訊號燈 */ while((wait(&status)==-1)&&(errno==EINTR)); /* 訊號燈只能夠被刪除一次的 */ if(i==1) if(del_semaphore(semid)==-1) fprintf(stderr,"[%d]:Destroy Semaphore Error:%s
a", getpid(),strerror(errno)); exit(0); } 訊號燈的主要用途是保護臨界資源(在一個時刻只被一個程式所擁有). 3。SystemV訊息佇列 為了便於程式之間通訊,我們可以使用管道通訊 SystemV也提供了 一些函式來實現程式的通訊.這就是訊息佇列. #include #include #include int msgget(key_t key,int msgflg); int msgsnd(int msgid,struct msgbuf *msgp,int msgsz,int msgflg); int msgrcv(int msgid,struct msgbuf *msgp,int msgsz, long msgtype,int msgflg); int msgctl(Int msgid,int cmd,struct msqid_ds *buf); struct msgbuf { long msgtype; /* 訊息型別 */ ....... /* 其他資料型別 */ } msgget函式和semget一樣,返回一個訊息佇列的標誌.msgctl和semctl是對訊息進行控制 .. msgsnd和msgrcv函式是用來進行訊息通訊的.msgid是接受或者傳送的訊息佇列標誌. msgp是接受或者傳送的內容.msgsz是訊息的大小. 結構msgbuf包含的內容是至少有一個 為msgtype.其他的成分是使用者定義的.對於傳送函式msgflg指出緩衝區用完時候的操作. 接受函式指出無訊息時候的處理.一般為0. 接收函式msgtype指出接收訊息時候的操作. 如果msgtype=0,接收訊息佇列的第一個訊息.大於0接收佇列中訊息型別等於這個值的第 一個訊息.小於0接收訊息佇列中小於或者等於msgtype絕對值的所有訊息中的最小一個消 息. 我們以一個例項來解釋程式通訊.下面這個程式有server和client組成.先執行服務 端後執行客戶端. 服務端 server.c #include #include #include #include #include #include #include #include #include #define MSG_FILE "server.c" #define BUFFER 255 #define PERM S_IRUSR|S_IWUSR struct msgtype { long mtype; char buffer[BUFFER+1]; }; int main() { struct msgtype msg; key_t key; int msgid; if((key=ftok(MSG_FILE,'a'))==-1) { fprintf(stderr,"Creat Key Error:%sa
",strerror(errno)); exit(1); } if((msgid=msgget(key,PERM|IPC_CREAT|IPC_EXCL))==-1) { fprintf(stderr,"Creat Message Error:%sa
",strerror(errno)); exit(1); } while(1) { msgrcv(msgid,&msg,sizeof(struct msgtype),1,0); fprintf(stderr,"Server Receive:%s
",msg.buffer); msg.mtype=2; msgsnd(msgid,&msg,sizeof(struct msgtype),0); } exit(0); } ---------------------------------------------------------------------------- ---- 客戶端(client.c) #include #include #include #include #include #include

linux作業系統下c語言程式設計入門(2)(轉)

相關文章