[关闭]
@MicroCai 2015-03-22T09:26:27.000000Z 字数 5988 阅读 3064

进程间通信的方式

计算机基础

「计算机基础」系列用以复习基础之用，文章整理自网络

本文代码是大学时期整理的，放在 我的 CSDN 下载频道，在 Linux 平台下全部编译通过。

管道

  1. #include <unistd.h>
  2. #include <sys/types.h>
  3. #include <errno.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  8. int main(void)
  9. {
  10.     int pipe_fd[2];
  11.     pid_t pid;
  12.     char r_buf[100];
  13.     char w_buf[4];
  14.     char* p_wbuf;
  15.     int r_num;
  16.     int cmd;
  18.     memset(r_buf, 0, sizeof(r_buf));
  19.     memset(w_buf, 0, sizeof(r_buf));
  20.     p_wbuf = w_buf;
  22.     if(pipe(pipe_fd) < 0)
  23.     {
  24.         printf("pipe create error\n");
  25.         return -1;
  26.     }
  28.     if((pid=fork()) == 0)
  29.     {
  30.         printf("child\n");
  32.         printf("\n");
  33.         close(pipe_fd[1]);
  35.         sleep(3);//确保父进程关闭写端
  37.         r_num = read(pipe_fd[0], r_buf,100);
  38.         printf("read num is %d the data read from the pipe is %d\n", r_num, atoi(r_buf));
  40.         close(pipe_fd[0]);
  42.         printf("child exit\n");
  43.     }
  44.     else if(pid > 0)
  45.     {
  46.         printf("parent\n");
  47.         close(pipe_fd[0]);//read
  48.         strcpy(w_buf, "111");
  49.         if(write(pipe_fd[1], w_buf,4) != -1)
  50.             printf("parent write over\n");
  52.         close(pipe_fd[1]);//write
  53.         printf("parent close fd[1] over\n");
  54.         printf("parent exit\n");
  55.     }     
  57.     exit(0);
  58. }

信号量

  1. /*
  2. 功能: 创建信号量
  3. 参数:
  4.     char *pszSemFile 文件名
  5.     char cId  ID
  6.     int iSems     多少个信号量
  7.     int *piInitvVal 对应信号量的初始值数组指针
  8. 返回:
  9.     -1 错误
  10.     成功信号量id
  11. */
  12. int CreateSem(char *pszSemFile, char cId, int iSems, int *piInitvVal)
  13. {
  14.     key_t key;
  15.     int iSemId;
  16.     int i;
  18.     if ((key = GetIpcKey(pszSemFile, cId)) < 0) 
  19.     {
  20.         WriteLogTxt(FILELINE, LOG_FILE, "GetIpcKey( %s, %d ) return %d", pszSemFile, cId, key);
  21.         return ( -1 );
  22.     }
  24.     if ((iSemId = semget(key, iSems, 0666|IPC_CREAT|IPC_EXCL)) < 0) 
  25.     {
  26.         if (errno == EEXIST) 
  27.         {
  28.             return(GetSem(pszSemFile, cId, iSems));
  29.         }
  30.         WriteLogTxt(FILELINE, LOG_FILE, "CreateSem(): Semget fail. errno[%d]", errno);
  31.         return(-1);
  32.     }
  34.     for (i = 0; i < iSems; i++) 
  35.     {
  36.         if (semctl(iSemId, i, SETVAL, piInitvVal[i]) < 0) 
  37.         {
  38.             WriteLogTxt(FILELINE, LOG_FILE, "CreateSem(): Semctl fail. errno[%d]", errno);
  39.             return(-1);
  40.         }   
  41.     }
  43.     return ( iSemId );
  44. }
  46. /*
  47. 功能: 获取信号量
  48. 参数:
  49.     char *pszSemFile 文件名
  50.     char cId  ID
  51.     int iSems     多少个信号量
  52. 返回:
  53.     -1 错误
  54.     成功信号量id
  55. */
  56. int GetSem(char *pszSemFile, char cId, int iSems)
  57. {
  58.     key_t key;
  59.     int iSemId;
  61.     if ((key = GetIpcKey(pszSemFile, cId)) < 0) 
  62.     {
  63.         WriteLogTxt(FILELINE, LOG_FILE, "GetIpcKey( %s, %d ) return %d", pszSemFile, cId, key);
  64.         return ( -1 );
  65.     }
  67.     if ((iSemId = semget(key, iSems, 0)) < 0) 
  68.     {
  69.         WriteLogTxt(FILELINE, LOG_FILE, "GetSem(): semget fail! errno[%d]", errno);
  70.         return(-1);
  71.     }
  73.     return (iSemId);
  74. }
  76. /*
  77. 功能: 信号量PV操作
  78. 参数:
  79.     char *pszSemFile 文件名
  80.     char cId  ID
  81.     int iSems     多少个信号量
  82.     struct sembuf *pstSemBuf
  83. 返回:
  84.     0 成功
  85.     其它错误
  86. */
  87. int PVSem(char *pszSemFile, char cId, int iSems, struct sembuf *pstSemBuf)
  88. {
  89.     int iSemId;
  91.     if ((iSemId = GetSem(pszSemFile, cId, iSems)) < 0)
  92.     {
  93.         return ( -1 );
  94.     }
  96.     if (semop(iSemId, pstSemBuf, 1) < 0) 
  97.     {
  98.         WriteLogTxt(FILELINE, LOG_FILE, "PV():Semaphore operater fail! errno[%d]", errno);
  99.         return ( -1 );
  100.     }
  102.     return ( 0 );
  103. }
  105. /*
  106. 功能: 删除信号量
  107. 参数:
  108.     char *pszSemFile 文件名
  109.     char cId  ID
  110.     int iSems     多少个信号量
  111. 返回:
  112.     0 成功
  113.     其它错误
  114. */
  115. int RmSem(char *pszSemFile, char cId, int iSems)
  116. {
  117.     int iSemId;
  119.     if ((iSemId = GetSem(pszSemFile, cId, iSems)) < 0)
  120.     {
  121.         return ( -1 );
  122.     }
  124.     if (semctl(iSemId, 0, IPC_RMID, 0) < 0) 
  125.     {
  126.         WriteLogTxt(FILELINE, LOG_FILE, "RmSem(): semctl fail! errno[%d]", errno);
  127.         return ( -1 );
  128.     }
  130.     return ( 0 );
  131. }

消息队列

  1. #include <sys/types.h>
  2. #include <sys/msg.h>
  3. #include <unistd.h>
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  8. void msg_stat(int, struct msqid_ds);
  10. int main(void)
  11. {
  12.     int gflags,sflags,rflags;
  13.     key_t key;
  14.     int msgid;
  15.     int reval;
  17.     struct msgsbuf{
  18.         int mtype;
  19.         char mtext[1024];
  20.     }msg_sbuf, msg_rbuf;
  22.     struct msqid_ds msg_ginfo,msg_sinfo;
  24.     char *msgpath="/root/msgid";
  26.     key=ftok(msgpath,'b');
  27.     gflags=IPC_CREAT;
  28.     msgid=msgget(key,gflags|00666);
  29.     if(msgid==-1)
  30.     {
  31.         printf("msg create error\n");
  32.         return;
  33.     }
  35.     //创建一个消息队列后，输出消息队列缺省属性
  36.     msg_stat(msgid,msg_ginfo);
  38.     sflags=IPC_NOWAIT;
  39.     msg_sbuf.mtype=10;
  40.     bzero(msg_sbuf.mtext, 1024);
  41.     strcpy(msg_sbuf.mtext, "hello\n");
  42.     reval=msgsnd(msgid,&msg_sbuf,sizeof(msg_sbuf.mtext),sflags);
  43.     if(reval==-1)
  44.     {
  45.         printf("message send error\n");
  46.     }
  48.     //发送一个消息后，输出消息队列属性
  49.     msg_stat(msgid,msg_ginfo);
  51.     rflags=IPC_NOWAIT|MSG_NOERROR;
  52.     reval=msgrcv(msgid,&msg_rbuf,1024,10,rflags);
  53.     if(reval==-1)
  54.         printf("read msg error\n");
  55.     else 
  56.     {
  57.         printf("read from msg queue %d bytes\n",reval);
  58.         printf("read from msg queue data: %s\n",msg_rbuf.mtext);
  59.     }
  61.     //从消息队列中读出消息后，输出消息队列属性
  62.     msg_stat(msgid,msg_ginfo);
  64.     msg_sinfo.msg_perm.uid=8;//just a try
  65.     msg_sinfo.msg_perm.gid=8;//
  66.     msg_sinfo.msg_qbytes=16388;
  68.     //此处验证超级用户可以更改消息队列的缺省msg_qbytes
  69.     //注意这里设置的值大于缺省值
  70.     reval=msgctl(msgid,IPC_SET,&msg_sinfo);
  71.     if(reval==-1)
  72.     {
  73.         printf("msg set info error\n");
  74.         return;
  75.     }
  77.     msg_stat(msgid,msg_ginfo);
  79.     //验证设置消息队列属性
  80.     reval=msgctl(msgid,IPC_RMID,NULL);//删除消息队列
  81.     if(reval==-1)
  82.     {
  83.         printf("unlink msg queue error\n");
  84.         return;
  85.     }
  86. }
  88. void msg_stat(int msgid,struct msqid_ds msg_info)
  89. {
  90.     int reval;
  92.     sleep(1);//只是为了后面输出时间的方便
  93.     reval=msgctl(msgid,IPC_STAT,&msg_info);
  94.     if(reval==-1)
  95.     {
  96.         printf("get msg info error\n");
  97.         return;
  98.     }
  100.     printf("\n");
  101.     printf("current number of bytes on queue is %d\n",msg_info.msg_cbytes);
  102.     printf("number of messages in queue is %d\n",msg_info.msg_qnum);
  103.     printf("max number of bytes on queue is %d\n",msg_info.msg_qbytes);
  105.     //每个消息队列的容量（字节数）都有限制MSGMNB，值的大小因系统而异。在创建新的消息队列时
  106.     //msg_qbytes的缺省值就是MSGMNB
  107.     printf("pid of last msgsnd is %d\n",msg_info.msg_lspid);
  108.     printf("pid of last msgrcv is %d\n",msg_info.msg_lrpid);
  109.     printf("last msgsnd time is %s", ctime(&(msg_info.msg_stime)));
  110.     printf("last msgrcv time is %s", ctime(&(msg_info.msg_rtime)));
  111.     printf("last change time is %s", ctime(&(msg_info.msg_ctime)));
  112.     printf("msg uid is %d\n",msg_info.msg_perm.uid);
  113.     printf("msg gid is %d\n",msg_info.msg_perm.gid);
  114. }

共享内存

  1. //fifo_read.c
  3. #include <sys/types.h>
  4. #include <sys/stat.h>
  5. #include <errno.h>
  6. #include <fcntl.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  11. #define FIFO_SERVER "/root/fifoserver"
  13. int main(int argc,char** argv)
  14. {
  15.     char r_buf[4096*2];
  16.     int  fd;
  17.     int  ret_size;
  19.     memset(r_buf,0,sizeof(r_buf));
  21.     if((mkfifo(FIFO_SERVER, S_IRUSR | S_IWUSR)<0)&&(errno!=EEXIST))
  22.           printf("cannot create fifoserver\n");
  24.     fd=open(FIFO_SERVER,O_RDONLY,0);
  26.     if(fd==-1)
  27.     {
  28.         printf("open %s for read error\n");
  29.         exit(1);     
  30.     }
  32.     while(1)
  33.     {
  34.         memset(r_buf,0,sizeof(r_buf));
  35.         ret_size=read(fd, r_buf, 4096);
  37.         if(ret_size==-1) 
  38.         {
  39.             printf("no data avlaible\n");
  40.             break;
  41.         }
  43.         printf("real read bytes %d\n", ret_size);
  44.         printf("real read : %s\n", r_buf);
  45.     }     
  47.     unlink(FIFO_SERVER);
  49.     exit(1); 
  50. }
  1. //fifo_write.c
  3. #include <sys/types.h>
  4. #include <sys/stat.h>
  5. #include <errno.h>
  6. #include <fcntl.h>
  7. #include <stdio.h>
  8. #include <stdlib.h>
  9. #include <string.h>
  11. #define FIFO_SERVER "/root/fifoserver"
  14. //参数为即将写入的字节数
  15. int main(int argc,char** argv)
  16. {
  17.     int fd;
  18.     char w_buf[4096*2];
  19.     int real_wnum;
  21.     memset(w_buf,0,4096*2);
  23.     fd=open(FIFO_SERVER, O_WRONLY|O_NONBLOCK);    //设置非阻塞标志
  25.     if(fd==-1){
  26.         printf("open error\n");
  27.         exit(1);
  28.     }
  30.     while (1)
  31.     {
  32.         strcpy(w_buf, "hello\n");       
  33.         real_wnum=write(fd,w_buf, strlen(w_buf));
  34.         if(real_wnum==-1) 
  35.         {
  36.             printf("write to fifo error\n");
  37.             break;
  38.         }
  39.         else 
  40.             printf("real write num is %d\n",real_wnum);
  42.         sleep(1);
  43.     }
  45.     exit(0);
  46. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注