Code666 (代码贴、代码片段)

[C] Linux下进程间通信（IPC-Inter process communic) →→→→→进入此内容的聊天室

来自 , 2021-01-16, 写在 C, 查看 99 次.
URL http://www.code666.cn/view/db60b95d
  1. //----------------方式：管道、消息队列、共享内存、信号量、套接口----------------
  2.  
  3. /*
  4.          管道：进程间通信最古老的方式，包括无名管道和有名管道，前者用于父子进程间的通信，后者用于同一台机器上的任意两个进程间通信。
  5. */
  6.  
  7. /*1>无名管道：只能在父子进程间通信，fd[0]：只读；fd[1]：只写。
  8. 函数原型：int pipe(int pipefd[2]);
  9. 例：
  10. //建立两个子进程，一个负责计算1-5000的素数，另外一个负责计算5001-10000，父进程负责存储
  11. */
  12. #include<stdio.h>
  13. #include<unistd.h>
  14. #include<fcntl.h>//要用到文件
  15. #include<stdlib.h>
  16. #include<string.h>
  17. #include<signal.h>
  18. #include<sched.h>
  19. int idx=0;
  20. int fddata;
  21. void handle(int s)
  22. {
  23.   int status;
  24.   if(s==SIGCHLD)
  25.   {
  26.     wait(&status);//回收节点
  27.     idx++;
  28.      if(idx==2)
  29.     {
  30.       close(fddata);
  31.       printf("任务完成\n");
  32.       exit(-1);
  33.     }
  34.   }
  35. }
  36. int isprimer(int data)
  37. {
  38.   int i=2;
  39.   for(;i<data;i++)
  40.   {
  41.     if(data%i==0)
  42.     {
  43.       return 0;
  44.     }
  45.   }
  46.   return 1;
  47. }
  48. main()
  49. {
  50.   int a,b;
  51.   int id=1;
  52.   int fd[2];
  53.   signal(SIGCHLD,handle);
  54.   pipe(fd);
  55.   while(1)
  56.   {
  57.     if(id==1)
  58.       {
  59.         a=2;
  60.         b=5000;
  61.       }
  62.       if(id==2)
  63.       {
  64.         a=5001;
  65.         b=10000;
  66.       }
  67.     if(fork())
  68.     {
  69.       //父进程
  70.       id++;
  71.       if(id>2)
  72.       {
  73.         break;
  74.       }
  75.       continue;
  76.     }
  77.     else
  78.     {
  79.       //子进程
  80.       int i;
  81.       close(fd[0]);
  82.       for(i=a;i<=b;i++)
  83.       {
  84.         if(isprimer(i))
  85.         {
  86.           write(fd[1],&i,sizeof(int));
  87.         }
  88.         sched_yield();
  89.       }
  90.       printf("%d任务完成!\n",getpid());
  91.      
  92.       exit(0);
  93.     }
  94.   }
  95.   int re;
  96.   char buf[20];
  97.   close(fd[1]);
  98.   fddata=open("result.txt",O_RDWR|O_CREAT,0666);
  99.   while(1)
  100.   {
  101.     int r;
  102.     //打开文件,准备存储
  103.     if(r=read(fd[0],&re,sizeof(int))==0)
  104.     {
  105.     sprintf(buf,"%d\n",re);//转化成文本
  106.     write(fddata,buf,strlen(buf));
  107.     sched_yield();
  108.     }
  109.   }
  110. }
  111. /*2>有名管道：有名管道提供一个路径名，这样在进程中通过这个路径名就可以访问，实现彼此通信；它严格遵循FIFO原则；
  112. 函数原型：int mkfifo(const char *pathname, mode_t mode);
  113. 例：
  114. */
  115. //程序A:
  116. #include<stdio.h>
  117. #include<fcntl.h>
  118. #include<unistd.h>
  119. #include<sys/stat.h>
  120. #include<signal.h>
  121. int fd;
  122. int i=0;
  123. void end(int s)
  124. {
  125.   //关闭管道
  126.   close(fd);
  127.   //删除管道
  128.   unlink("my.pipe");
  129. }
  130. main()
  131. {
  132.   signal(SIGINT,end);
  133.   //建立管道
  134.   mkfifo("my.pipe",0666);
  135.   //打开管道
  136.   fd=open("my.pipe",O_RDWR);
  137.   while(1)
  138.   {
  139.     //每隔一秒钟写一个数据
  140.     sleep(1);
  141.     write(fd,&i,4);
  142.     i++;
  143.   }
  144.  
  145. }
  146. //程序B：
  147. #include<stdio.h>
  148. #include<fcntl.h>
  149. #include<unistd.h>
  150. #include<sys/stat.h>
  151. #include<signal.h>
  152. int fd;
  153. int i=0;
  154. void end(int s)
  155. {
  156.   //关闭管道
  157.   close(fd);
  158.   //删除管道
  159.   unlink("my.pipe");
  160. }
  161. main()
  162. {
  163.   signal(SIGINT,end);
  164.   //建立管道
  165.   mkfifo("my.pipe",0666);
  166.   //打开管道
  167.   fd=open("my.pipe",O_RDWR);
  168.   while(1)
  169.   {
  170.     //每隔一秒钟读一个数据
  171.     sleep(1);
  172. read(fd,&i,4);
  173. printf(“%d\n”,i);
  174.     i++;
  175.   }
  176. }
  177. /*
  178.          消息队列：消息队列的内核持续性要求每个消息队列在系统范围内对应唯一的键值key。
  179. */
  180. //数据结构
  181. struct msgbuf
  182. {
  183.   long type;
  184.   char data[32];
  185. };
  186. //例：
  187. //------------程序A：-----------
  188. #include<stdio.h>
  189. #include<unistd.h>
  190. #include<sys/msg.h>
  191. #include<stdlib.h>
  192. #include<string.h>
  193. #include<sys/ipc.h>
  194. struct msgbuf
  195. {
  196.   long type;
  197.   char data[32];
  198. };
  199. main()
  200. {
  201.   key_t key;
  202.   int msgid;
  203.   int i;
  204.   //创建消息队列
  205.   key=ftok(".",255);
  206.   if(key==-1) printf("ftok error:%m\n"),exit(-1);
  207.   msgid=msgget(key,IPC_CREAT|IPC_EXCL|0666);
  208.   if(msgid==-1) printf("get error:%m\n"),exit(-1);
  209.   printf("msggid:%d\n",msgid);
  210.   //构造消息
  211.   struct msgbuf msg;
  212.   //发送消息
  213.   for(i=1;i<=10;i++)
  214.   {
  215.     bzero(msg.data,sizeof(msg.data));
  216.     msg.type=1;
  217.     sprintf(msg.data,"Massage:%d",i);
  218.    
  219.     msgsnd(msgid,&msg,sizeof(msg.data),0);
  220.   }
  221.   //exit(0);
  222.   //删除消息
  223.  // msgctl(msgid,IPC_RMID,0);
  224. }
  225. //---------程序B：----------
  226. #include<stdio.h>
  227. #include<unistd.h>
  228. #include<sys/msg.h>
  229. #include<stdlib.h>
  230. #include<string.h>
  231. #include<sys/ipc.h>
  232. struct msgbuf
  233. {
  234.   long type;
  235.   char data[32];
  236. };
  237. main()
  238. {
  239.   key_t key;
  240.   int msgid;
  241.   int i;
  242.   //得到消息队列
  243.   key=ftok(".",255);
  244.   if(key==-1) printf("ftok error:%m\n"),exit(-1);
  245.   msgid=msgget(key,0);
  246.   printf("msggid:%d\n",msgid);
  247.   if(msgid==-1) printf("get error:%m\n"),exit(-1);
  248.   //构造消息
  249.   struct msgbuf msg;
  250.   //接受消息
  251.   while(1)
  252.   {
  253.     bzero(&msg,sizeof(msg));
  254.     msgrcv(msgid,&msg,sizeof(msg.data),1,0);//第四个参数代表所取消息类型
  255.     printf("%s\n",msg.data);
  256.   }
  257. }
  258.  
  259. /*
  260.          共享内存：它是运行在同一台机器上的进程间通信最快的方式，因为数据不需要在不同的进程间复制；通常由一个进程创建一块共享内存区，其余进程对这块内存区进行读写。
  261. */
  262. //例：
  263. //----------程序A：-------------
  264. #include<stdio.h>
  265. #include<stdlib.h>
  266. #include<string.h>
  267. #include<unistd.h>
  268. #include<signal.h>
  269. #include<sys/shm.h>
  270. #include<sys/ipc.h>
  271. key_t key;
  272. int shmid;
  273. int *p;
  274. int i=0;
  275. void deal(int s)
  276. {
  277.   if(s==SIGINT)
  278.   {
  279.    //4.卸载共享内存shmdt
  280.     shmdt(p);
  281.   //5.删除共享内存shctl
  282.     shmctl(shmid,IPC_RMID,0);
  283.     exit(0);
  284.   }
  285. }
  286. main()
  287. {
  288.   signal(SIGINT,deal);
  289.   //1.创建共享内存shmget
  290.   key=ftok(".",255);//'.'代表当前目录
  291.   //if(key=-1) printf("ftok error:%m\n"),exit(-1);
  292.   shmid=shmget(key,4,IPC_CREAT|IPC_EXCL|0666);
  293.   if(shmid==-1) printf("get error:%m\n"),exit(-1);
  294.   //2.挂载共享内存shmat
  295.   p=shmat(shmid,0,0);
  296.   if(p==(int*)-1) printf("at error:%m\n"),exit(-1);
  297.   //3.访问共享内存
  298.   while(1)
  299.   {
  300.     *p=i;
  301.     sleep(3);
  302.     i++;
  303.   }
  304. }
  305.  
  306. //-------------程序B：-----------
  307. #include<stdio.h>
  308. #include<stdlib.h>
  309. #include<string.h>
  310. #include<unistd.h>
  311. #include<signal.h>
  312. #include<sys/shm.h>
  313. #include<sys/ipc.h>
  314. key_t key;
  315. int shmid;
  316. int *p;
  317. void deal(int s)
  318. {
  319.   if(s==SIGINT)
  320.   {
  321.    //4.卸载共享内存shmdt
  322.     shmdt(p);
  323.     exit(0);
  324.   }
  325. }
  326. main()
  327. {
  328.   signal(SIGINT,deal);
  329.   //1.创建共享内存shmget
  330.   key=ftok(".",255);
  331.   //if(key=-1) printf("ftok error:%m\n"),exit(-1);
  332.   shmid=shmget(key,4,0);
  333.   if(shmid==-1) printf("get error:%m\n"),exit(-1);
  334.   //2.挂载共享内存shmat
  335.   p=shmat(shmid,0,0);
  336.   if(p==(int*)-1) printf("at error:%m\n"),exit(-1);
  337.   //3.访问共享内存
  338.   while(1)
  339.   {
  340.     sleep(1);
  341.     printf("%d\n",*p);
  342.   }
  343. }
  344.  
  345. /*
  346.           信号量：又称信号灯，用来协调不同进程间的数据对象的，是在多线程环境下使用的一种设施，可以用来保证两个或者多个关键代码段不被并发调用。
  347. */
  348. struct sembuf{
  349. int sem_num；//下标
  350. int sem_op;
  351. int sem_flg;
  352. };
  353. //例：
  354. //---------程序A：-----------
  355. #include<stdio.h>
  356. #include<unistd.h>
  357. #include<sys/sem.h>
  358. #include<sys/ipc.h>
  359. #include<stdlib.h>
  360. union semun {
  361.        int val;    
  362.        struct semid_ds *buf;    
  363.        unsigned short  *array;  
  364.        struct seminfo  *__buf;  
  365. };
  366. main()
  367. {
  368.   key_t key;
  369.   int semid;
  370.   union semun v;
  371.   int r;
  372.   struct sembuf op[1];
  373.   //1.创建信号量
  374.   key=ftok(".",99);
  375.   if(key==-1) printf("ftok err:%m\n"),exit(-1);
  376.   semid=semget(key,1/*信号量数组个数*/,IPC_CREAT|IPC_EXCL|0666);
  377.   //semid=semget(key,1,0);//得到信号量
  378.   if(semid==-1) printf("get err:%m\n"),exit(-1);
  379.  
  380.   //2.初始化信号量
  381.   v.val=2;//任意值，被下面op[0].sem_op=-1;操作
  382.   semctl(semid,0,SETVAL,v);//设置信号量,其中第二个参数是要执行操作信号量的编号
  383.   if(r==-1) printf("初始化失败!\n"),exit(-1);
  384.   //3.对信号量进行阻塞操作
  385.   //3.1定义操作
  386.   op[0].sem_num=0;//信号量的下标
  387.   op[0].sem_op=-1;//信号量的操作单位和类型
  388.   op[0].sem_flg=0;
  389.   while(1)
  390.   {
  391.     semop(semid,op,1);//第三个参数，即op数组个数
  392.     printf("解除阻塞!\n");
  393.   }
  394.   //4.删除信号量（可以不删除）
  395.  semctl(semid,0,IPC_RMID,0);
  396.  
  397. }
  398. //------------程序B：-----------
  399. #include<stdio.h>
  400. #include<unistd.h>
  401. #include<sys/sem.h>
  402. #include<sys/ipc.h>
  403. #include<stdlib.h>
  404. union semun {
  405.        int val;    
  406.        struct semid_ds *buf;    
  407.        unsigned short  *array;  
  408.        struct seminfo  *__buf;  
  409. };
  410.  
  411. main()
  412. {
  413.   key_t key;
  414.   int semid;
  415.   union semun v;
  416.   //int r;
  417.   struct sembuf op[1];
  418.   //1.创建信号量
  419.   key=ftok(".",99);
  420.   if(key==-1) printf("ftok err:%m\n"),exit(-1);
  421.   semid=semget(key,1,0);//得到信号量
  422.   if(semid==-1) printf("get err:%m\n"),exit(-1);
  423.   //2.初始化信号量
  424.   //3.对信号量进行阻塞操作
  425.   //3.1定义操作
  426.   op[0].sem_num=0;//信号量的下标
  427.   op[0].sem_op=1;//信号量的操作单位和类型
  428.   op[0].sem_flg=0;
  429.   while(1)
  430.   {
  431.     semop(semid,op,1);
  432.     sleep(1);
  433.   }
  434.   //4.删除信号量（可以不删除）
  435. }
  436.  
  437. /*
  438.          套接口socket：网络通信方式
  439. */
  440. /*阻塞与非阻塞：
  441. 1>阻塞：
  442. 简单的的说，阻塞就是当你调用accept()，send()或者是recv()等过程后，程序必须要等待一个返回结果程序才会继续执行下去，在这种情况下，如果你是单线程的，那么你的程序就会完全挂起。
  443. 2>非阻塞：
  444. 非阻塞套接字是指，执行此套接字的网络调动时，不管是否执行成功，都立即返回；
  445. 简单的说，同步阻塞常用于连接较少流量较大的地方；非阻塞常用于连接较多，流量较少的地方。
  446. 使用selece()函数，函数原型；nt PASCAL FAR select( int nfds, fd_set FAR* readfds,　fd_set FAR* writefds, fd_set FAR* exceptfds,　const struct timeval FAR* timeout);
  447. 在讲解select()函数之前我们先讲一下fd_set.
  448. 它表示一个集合.具体的讲是一个文件描述符的集合.在此例中都把它理解为套接字描述符.
  449. 在Unix中一切都是文件.包括输入设备键盘.硬盘上的文件.还有专门用于网络传输的socket(套接字)等等.所以.在这里都把它当作是socket套接字.
  450. 那么文件描述符或者是套接字描述符就好比是WINDOWS下面的句柄.
  451. fd_set的定义如下:
  452. struct fd_set
  453. {
  454.         u_int   fd_count;              
  455.         SOCKET  fd_array[FD_SETSIZE];  
  456. };
  457. 对这些集合的操作都是通过一些特定的宏来完成的.
  458.     FD_ZERO(fd_set *set)          //清除一个文件描述符集合
  459. 　　    FD_SET(int fd, fd_set *set)   //把fd添加到集合set中
  460. 　　    FD_CLR(int fd, fd_set *set)   //从集合set中移去fd
  461. 　　    FD_ISSET(int fd, fd_set *set) //测试fd是否在集合set中
  462. 现在再来说说select()函数,以及它的用法.
  463. 该函数的功能就是用来等待套接字(这里只讨论套接字)状态的改变.
  464. 参数nums代表最大的套接字描述符加1.
  465. 参数reads,writes和excepts是套接字描述符集合,用来回传该套接字描述符的读,写或例外的状况.
  466. 参数timeout指向一个timeval结构.它用来设定select等待的时间.可以设置到微秒级.1秒等于1000毫秒.1毫秒等于1000微秒.虽然可以精确到1微秒.但这只是理想的.实际上跟系统还有硬件有关.
  467. timeval结构的定义如下:
  468. struct timeval
  469. {
  470. 　　 int tv_sec;
  471. 　　 int tv_usec; 
  472. };
  473. 当然你可以将参数timeout设置成NULL,那么它将永远不会超时.
  474. 成功返回套接字描述状态改变的个数,如果返回0表示在套接字描述符状态改变前已经超过参数timeout设定的时间.当有错误发生时则返回-1.此时参数reads,writes,execepts和timeout的值变得不可预测.
  475. 同时有错误发生时,它会设置全局错误变量.常见错误有下面几种.
  476. EBADF 套接字描述符无效或该套接字已关闭
  477. EINTR 此调用被信号所中断
  478. EINVAL 参数n 为负值
  479. ENOMEM 核心内存不足*/

回复 "Linux下进程间通信（IPC-Inter process communic)"

这儿你可以回复上面这条便签

captcha

贴代码片段 - Code666