进程间的通信

最新推荐文章于 2023-05-16 20:07:43 发布
最新推荐文章于 2023-05-16 20:07:43 发布
阅读量444 收藏
点赞数
分类专栏： linux环境编程 文章标签： c语言 通信 shell linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thearcticocean/article/details/54290809
版权
本文详细介绍了Linux下的进程间通信方式，包括信号、管道、命名管道、消息队列和共享内存。信号如SIGKILL和SIGSTOP无法被程序捕获，而管道是半双工的，适用于父子或兄弟进程。命名管道FIFO则允许任意两个进程通信。消息队列是内核中存储的消息列表，允许自定义读写。共享内存提供了快速的通信机制，无需数据复制。
摘要由CSDN通过智能技术生成

信号

信号是软件中断的模拟，可以在任何时候发给进程，如果进程处于未执行状态，该信号就由内核保存，直到进程恢复执行再传递给它。
SIGKILL和SEGSTOP是应用程序无法捕捉和忽略的。
几个常用的快捷键和信号：
ctrl + C —— SIGINT 中断信号
ctrl + \ —— SIGQUIT 退出信号
ctrl + Z —— SIGTSTP 进程挂起
functions about signals:

functionintroduction
int kill(pid_t pid, int sig)send signal to a process
int raise(int sig)send a signal to the caller
unsigned int alarm(unsigned int seconds)set an alarm clock for delivery of a signal
int pause(void)wait for signal
typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler);ANSI C signal handling
int sigemptyset(sigset_t *set)initializes the signal set given by set to empty, with all signals excluded from the set.
int sigfillset(sigset_t *set)initializes set to full, including all signals
int sigaddset(sigset_t *set, int signum)add respectively signal signum from set
int sigdelset(sigset_t *set, int signum)delete respectively signal signum from set
int sigismember(const sigset_t *set, int signum)tests whether signum is a member of set
int sigprocmask(int how, const sigset_t *set, sigset_t *oldset)examine and change blocked signals

下面是子进程给自己发送SIGSTOP信号，用于暂停进程。父进程中waitpid(pid,0,WNOHANG) 用于子进程没有退出立即返回（return immediately if no child has exited.）。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>

int main(){
    pid_t pid = fork();
    if(pid == 0){ // child
         printf("child id is %d\n",getpid());
         raise(SIGSTOP);
    }
    else if(pid > 0){ // father
         printf("father pid is %d\n",getpid());
         if(waitpid(pid,0,WNOHANG) == 0){ 
              int ret = kill(pid,SIGKILL);
              if(ret < 0) perror("ending child failed ");
              else printf("father process end child process.\n");
         }   
    }
    else {
         perror("fork ");
         exit(1);
    }
    return 0; 
}
/*
father pid is 6284
father process end child process.
*/

alarm用于设置多少秒后发出SIGALAR信号，时间片函数控制事件发生的时间点。

#include <stdio.h>
#include <signal.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>

void handler(int sig){
    printf("hello world\n");
}
int main(){
    int i;
    alarm(3);
    signal(SIGALRM,handler);
    for(i=1;i<=6;i++){
        printf("times is %d\n",i);
        sleep(1);
    }   
    return 0; 
}
/*
times is 1
times is 2
times is 3
hello world
times is 4
times is 5
times is 6
*/

信号的阻塞：

#include <stdio.h>
#include <stdlib.h>
#include <signal.h> 
void handler(){
    printf("signal SIGINT has been blocked for 5 seconds, now it works.\n");
}
int main(){
    signal(SIGINT,handler);
    int i;
    sigset_t set;
    if(sigemptyset(&set) == -1){
        perror("sigemptyset ");
    }
    if(sigaddset(&set,SIGINT) == -1){
        perror("sigaddset ");
    }
    if(sigprocmask(SIG_BLOCK,&set,NULL) == -1){ /* make set blocked */
        perror("sigpromask ");
    }
    raise(SIGINT);
    for(i=0;i<5;i++){
        printf("sleeps %d seconds...\n",i+1);
        sleep(1);
    }
    if(sigprocmask(SIG_UNBLOCK,&set,NULL) < 0){
        perror("sigprocmask ");
    }
    return 0;
}
/*
sleeps 1 seconds...
sleeps 2 seconds...
sleeps 3 seconds...
sleeps 4 seconds...
sleeps 5 seconds...
signal SIGINT has been blocked for 5 seconds, now it works.
*/

管道

进程通信方式中的管道是半双工的，仅用于父子进程或者兄弟进程，单独构成独立的文件系统，存在于内存之中。
相关的函数：

functionintroduction
int pipe(int pipefd[2])create pipe
int pipe2(int pipefd[2], int flags)create pipe
FILE *popen(const char *command, const char *type)opens a process by creating a pipe, forking, and invoking the shell
int pclose(FILE *stream)waits for the associated process to terminate and returns the exit status of the command as returned by wait4(2)
int mkfifo(const char *pathname, mode_t mode)make a FIFO special file (a named pipe)

例子：fork()创建进程，父进程给子进程通过管道发送消息“I’m father.”, 子进程读取；子进程给父进程发送消息“I’m child.”， 父进程再读取。

#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>

int main(){
    int pipe_fd[2];
    if(pipe(pipe_fd) < 0){
        perror("pipe ");
        exit(1);
    }
    int bytes;
    char str[105] = {0};
    int pid = fork();
    if(pid < 0) perror("fork ");
    else if(pid == 0){ // child
        bytes = read(pipe_fd[0],str,104);
        if(bytes > 0){
             printf("child read from pipe: %s\n",str);
        }
        else perror("child read ");
        //fdopen(pipe_fd[1],"w");
        bytes = write(pipe_fd[1],"I'm child.",104);
        if(bytes <= 0){
             perror("child write ");
             printf("child write %d\n",errno);
             exit(1);
        }
    }
    else {
        bytes = write(pipe_fd[1],"I'm father.",104);
        if(bytes <= 0){
             perror("father write ");
             exit(1);
        }
        waitpid(pid,NULL,0);  // wait for child process.
        bytes = read(pipe_fd[0],str,104);
        if(bytes > 0){
             printf("father read from pipe: %s\n",str);
        }
        else perror("father read ");
    }
    return 0;
}
/*
works:
child read from pipe: I'm father.
father read from pipe: I'm child.

if we put "waitpid(pid,NULL,0);" after "else perror("father read ");",
we would find read is blocked:
father read from pipe: I'm father.
^C

we can also get that process has individual pipe_fd[] for himself.
*/

使用管道实现ls |grep .c程序：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>

int main(){
    FILE *fp = popen("ls","r"); /* read pipe */
    if(fp == NULL){
         perror("popen ");
         exit(1);
    }
    char buf[1005]={0};
    if(fread(buf,1,1004,fp) <= 0){ /* store contents in buf */
         perror("fread ");
         exit(1);
    }
    pclose(fp);
    fp = popen("grep -a .c","w"); /* write pipe */
    if(fwrite(buf,1,1004,fp) <= 0){ /* write contents from buf to file stream fp */
         perror("fwrite ");
         exit(1);    
    }
    while(fgets(buf,1004,fp) != NULL){
        printf("%s\n",buf);
    }
    pclose(fp);
    return 0;
}
/*
it's equal to shell command `ls |grep .c`
*/

popen()中的shell命令是在fork出来的子进程中执行的。

命名管道

命名管道FIFO是一种特殊的pipe，可以使用在任何两个进程中通信。
相关函数:

int mkfifo(const char *pathname, mode_t mode);
int open(const char *pathname, int flags);
int open(const char *pathname, int flags, mode_t mode);
ssize_t read(int fd, void *buf, size_t count);
ssize_t write(int fd, const void *buf, size_t count);
int close(int fd);

下面实现两个进程的命名管道通信。
（open操作管道，以读或者写的方式打开，如果没有另一个进程进行写或读，是会一直阻塞的，fifo存在自动阻塞的特性。可以使用读写的方式打开避免这样的尴尬。）
processA.c:

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <sys/select.h>
#include <fcntl.h>

int main(){
    mkfifo("fifo1",0644);
    mkfifo("fifo2",0644);
    int wfd = open("fifo1",O_RDWR);
    int rfd = open("fifo2",O_RDWR);
    struct timeval timer = {0,0};
    fd_set wfd_set, rfd_set;

    if(wfd == -1 || rfd == -1){
        perror("open ");
        exit(1);
    }
    printf("process A:\n");
    while(1){
        FD_ZERO(&rfd_set);
        FD_SET(rfd,&rfd_set);
        FD_SET(fileno(stdin),&rfd_set);
        if(select(rfd+1,&rfd_set,NULL,NULL,&timer) <= 0) continue;
        if(FD_ISSET(rfd,&rfd_set)){
            char str[105] = {0};
            read(rfd,str,104);
            printf("message from process B: %s\n",str);
        }
        if(FD_ISSET(fileno(stdin),&rfd_set)){
            char str[105] = {0};
            fgets(str,104,stdin);
            if(write(wfd,str,strlen(str)) <= 0){
                perror("write ");
                exit(1);
            }       
        }
    }
    close(rfd);
    close(wfd);
    return 0;
}
/*
process A:
hello, I'm process A
message from process B: I get it

I'm glad to heard from you.
message from process B: see you later.


*/

processB.c

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <sys/select.h>
#include <fcntl.h>

int main(){
    mkfifo("fifo1",0644);
    mkfifo("fifo2",0644);
    int rfd = open("fifo1",O_RDWR);
    int wfd = open("fifo2",O_RDWR);
    struct timeval timer = {0,0};
    fd_set wfd_set, rfd_set;

    if(wfd == -1 || rfd == -1){
        perror("open ");
        exit(1);
    }
    printf("process B:\n");
    while(1){
        FD_ZERO(&rfd_set);
        FD_SET(rfd,&rfd_set);
        FD_SET(fileno(stdin),&rfd_set);
        if(select(rfd+1,&rfd_set,NULL,NULL,&timer) <= 0) continue;
        if(FD_ISSET(rfd,&rfd_set)){
            char str[105] = {0};
            read(rfd,str,104);
            printf("message from process A: %s\n",str);
        }
        if(FD_ISSET(fileno(stdin),&rfd_set)){
            char str[105] = {0};
            fgets(str,104,stdin);
            if(write(wfd,str,strlen(str)) <= 0){
                perror("write ");
                exit(1);
            }       
        }
    }
    close(rfd);
    close(wfd);
    return 0;
}
/*
process B:
message from process A: hello, I'm process A

I get it
message from process A: I'm glad to heard from you.

see you later.

*/

我们可以在当前目录下发现多了两个fifo文件：

$ ls -l fifo*
prw-r--r-- 1 edemon edemon 0  1月  7 16:26 fifo1
prw-r--r-- 1 edemon edemon 0  1月  7 16:26 fifo2

消息队列

消息队列是保存在内核中的消息列表。用户进程可以向消息队列中添加消息，也可以从消息队列中（自定义）读取消息。通信的进程没有关系上的 限制。
消息队列的相关函数
IPC: inter-process communication

functionsintroduction
key_t ftok(const char *pathname, int proj_id)convert a pathname and a project identifier to a System V IPC key
int msgget(key_t key, int msgflg)get a System V message queue identifier
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg)send messages to a System V message queue
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg)receive messages from a System V message queue
int msgctl(int msqid, int cmd, struct msqid_ds *buf)System V message control operations

例子：使用消息队列，父进程给子进程发送消息。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

int main(){
    key_t key = ftok(".",0);
    int msg_id = msgget(key,IPC_CREAT|0644);
    if(msg_id == -1){
        perror("msgget ");
        exit(1);
    }   
    printf("please enter message to transform: \n");
    char message[105] = {0};  
    fgets(message,104,stdin);
    int pid = fork();
    if(pid == -1){
        perror("fork ");
        exit(1);
    }
    else if(pid == 0){
        if(msgsnd(msg_id,message,strlen(message),0) == -1) {
            perror("msgsnd ");
            exit(1);
        }
    }
    else {
        waitpid(pid,NULL,0);
        memset(message,0,sizeof(message));
        if(msgrcv(msg_id,message,104,0,0) <= 0){
            perror("msgrcv ");
            exit(1);
        }
        printf("father process receive message from child process:\n%s",message);
        if(msgctl(msg_id,IPC_RMID,NULL) == -1){
            perror("msgctl ");
            exit(1);
        }
    }
    return 0;
}
/*
please enter message to transform: 
hello world
father process receive message from child process:
hello world
*/

共享内存

共享内存用于多个进程之间的通信，因为不需要数据的来回复制，所以是最快的进程之间通信的机制。

functionintroduction
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)map files or devices into memory
int munmap(void *addr, size_t length)unmap files or devices into memory
int shmget(key_t key, size_t size, int shmflg)allocates a shared memory segment
void *shmat(int shmid, const void *shmaddr, int shmflg)shared memory operations
int shmdt(const void *shmaddr)detaches the shared memory segment

系统V共享内存的方式（The POSIX shared memory object），通过映射特殊文件系统shm中的文件实现共享内存的通信。
例子：利用系统V共享内存的通信方法，子进程给父进程发送信息。

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>        /* For mode constants */
#include <fcntl.h>           /* For O_* constants */

int main(){
    int fd = shm_open("test",O_CREAT|O_RDWR,0644);
    if(fd == -1){
        perror("shm_open ");
        exit(1);
    }
    ftruncate(fd,105);
    char *str = (char *)mmap(NULL,105,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if((void*)-1 == str){
        perror("mmap ");
        exit(1);
    }
    int pid = fork();
    if(pid == -1)   perror("fork ");
    else if(pid == 0){
        printf("child process %d set message str.\n",getpid());
        strcpy(str,"hello world, I'm child.");
        exit(0);
    }
    else {
        waitpid(pid,0,0);
        printf("father process get share memory message: %s\n",str);
        if(munmap(str,105)<0) perror("munmap ");
        str = NULL;
    }
    return 0;
}
/*
shm_open, shm_unlink:  Link with -lrt.

[edemon@CentOS workspace]$ gcc shm_com.c -lrt
[edemon@CentOS workspace]$ ./a.out 
child process 8049 set message str.
father process get share memory message: hello world, I'm child.

we can find a new file test in /dev/shm/
[edemon@CentOS workspace]$ ls /dev/shm
pulse-shm-1359020668  pulse-shm-2129357730  pulse-shm-3531010208  test
pulse-shm-1643945986  pulse-shm-3326717209  pulse-shm-3944084079
*/

如果使用普通文件映射，那么改变open的方式即可。int fd = open("test",O_CREAT|O_RDWR|O_TRUNC,0644);
如果使用匿名映射（没有文件和内存对应），那么不使用shm_open和open函数产生文件描述符，使用mmap(): char *str = (char *)mmap(NULL,105,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,0);
在路径/proc/sys/kernel中存在共享内存最大字节数的限制文件shmnmax, 最大标识数的限制文件shmmni

[edemon@CentOS kernel]$ cat shmmax
4294967295
[edemon@CentOS kernel]$ cat shmmni
4096

文件系统shm安装点在交换分区上，系统V共享内存随着内核持续，系统重新引导（内核重新引导）后，所有的内存都将丢失。

[edemon@CentOS workspace]$ ls /dev/shm 
pulse-shm-1812859712  pulse-shm-2430381189  pulse-shm-264722293  pulse-shm-4074297125  pulse-shm-94801651
theArcticOcean
关注
专栏目录
系统编程之管道篇
bluzelee2011的专栏
08-22 716
管道（一） 一、 q 我们把从一个进程连接到另一个进程的一个数据流称为一个“管道” q 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道 q 只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。 二、匿名管道pipe   q 包含头文件 q 功能:创建一无
LINUX 进程间通信程序设计
海燕
05-16 547
进程间通讯概述 目的 为什么进程间需要通信？         1、数据传输                 一个进程需要将它的数据发送给另一个进程。         2、资源共享                 多个进程之间共享同样的资源。         3、通知事件                 一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件。
系统编程3：进程间通信
qq_43643506的博客
01-16 205
pipe函数； fd【0】读；fd【1】写 无名管道：有血缘关系的进程，比如父子进程，管道也属于文件； 例句：ret =pipe（fd）； //创建无名管道 pid =fork（）； //先创建管道，再创建子进程。 else if (0 == pid) //子进程 { close(fd[0]); a++; ret = write(fd[1], &amp;a, si...
计算机系统大作业
littlebear_的博客
05-20 186
计算机系统大作业
【进程复制】
m0_56246173的博客
11-15 412
输出六个程序刚开始进入进程复制时 ,i都等于0，我们首先执行父进程，父进程先输出一个A，再次进入循环，父进程又一次进行分裂，分裂之后的父子进程i=1，所以此处的父子进程都会输出一个A，第一次分裂之后的父进程输出三个A，再看第一次分裂之后的子进程，同父进程一样，先输出一个A，再次进入循环，再次分裂，分裂的两个程序都输出A，所以第一次分裂的子进程输出三个A，随意总共输出6个A，如图。此处是三个A，考察返回值。此处输出两个A，程序刚开始先进行复制，父进程继续向下运行，输出一个A，子进程也继续输出一个A。
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
Python中的进程间通信
12-20
Python中的进程间通信（IPC，Inter-Process Communication）是指不同进程之间交换信息的方式。在多进程编程中，由于进程间的独立性，它们不能直接访问彼此的内存空间，因此需要通过特定的方法来协调和同步进程间的...
C#使用SendMessage实现进程间通信的方法
09-03
在C#编程中，进程间通信（IPC，Inter-Process Communication）是一种允许不同进程之间交换数据的技术。在本文中，我们将探讨如何使用Windows API中的`SendMessage`函数在两个C#进程中实现这一通信方式。 `...
父子进程拷贝文件
09-01
linux C语言，编程实现父子进程同时拷贝文件，各复制一半
Linux进程间通信–使用信号
01-11
但它们还可以作为进程间通信或修改行为的一种方式，明确地由一个进程发送给另一个进程。一个信号的产生叫生成，接收到一个信号叫捕获。 二、信号的种类 信号的名称是在头文件signal.h中定义的，信号都以SIG开头，...
ipcs命令 多进程间通信常用的工具
01-09
ipcs命令是用于报告Linux中进程间通信设施的状态，显示的信息包括消息列表、共享内存和信号量的信息 。 语法格式：ipcs [参数] 常用参数： -a 默认的输出信息 -m 打印出使用共享内存进行进程间通信的信息 -q ...
Linux学习-进程管理
skyline_zx的专栏
10-09 397
创建进程 Linux系统中，调用fork函数通过复制一个现有进程来创建一个新的进程，在调用结束时，再返回点这个相同的位置上，父进程恢复执行，子进程开始执行。Linux的fork使用写时拷贝（copy-on-write）页实现，资源的复制只有在写入时才进行，在此之前，只以只读方式共享，这种技术使地址空间上的页的拷贝被推迟到实际发生写入时才进行。fork的实际开销就是复制父进程的页表以及给子进程创建
进程间通信之管道篇
最新发布
JJR_YZ的博客
05-16 883
进程间通信管道的笔记
进程间通信之管道通信
believe_s的博客
08-17 617
两个程序之间传递数据的一种简单方法是使用popen和pclose。#include <stdio.h> FILE *popen(const char *command, const char *type); int pclose(FILE *stream); popen函数允许一个程序将另一个程序作为新进程来启动，并可以传递数据给它或者通过它接收数据。
父子进程通过管道实现文件复制
FXJ303900773的博客
08-14 735
利用管道实现文件复制：1、父程序读端关闭，写端先将文件数据写入管道；2、子程序将写端关闭，然后从管道里读文件数据。 #include #include #include #include #include #include #define SIZE 1024 // 子进程通过管道从父进程接收数据 void child_do(int *fd) { //关闭管道写端 cl
【Linux程序设计】之进程间的通信
weixin_34197488的博客
12-11 443
这个系列的博客贴的都是我大二的时候学习Linux系统高级编程时的一些实验程序，都挺简单的。 实验题目：Linux环境下的进程间通信 实验目的：熟悉进程通信中信号概念及信号处理；掌握进程间的管道通信编程；了解进程间的内存共享编程。 实验内容： 一、信号 设计程序，满足如下要求： 1、编程程序：每隔1秒显示“running….”一次，显示8次后，程序结束。应用函数alarm，在程序开始运行...
linux图形编程之SDL
theArcticOcean
01-14 5736
SDL startSDL是编写跨平台游戏和多媒体应用的支持库，包含了对图形、声音、游戏杆、线程等支持，内容丰富、应用广泛。 ubuntu15.04上安装SDL: Source Code在 http://www.libsdl.org/download-1.2.php上，下载SDL-1.2.15.tar.gz。解压tar -zxvf SDL-1.2.15.tar.gz，在加压后的文件夹SDL-1.2
Linux进程间通信机制详解
"Linux进程间通信的PPT，涵盖了进程间通信概述、管道通信、信号、共享内存和消息队列等内容，介绍了多种Unix和System V进程间通信方式以及POSIX标准的通信机制。" 在计算机系统中，进程间通信（Inter-Process ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值