进程间通信具体实现代码（两个程序间互发信息）

最新推荐文章于 2021-04-30 10:42:39 发布
最新推荐文章于 2021-04-30 10:42:39 发布
阅读量1.2k 收藏 15
点赞数 1
文章标签： 通信
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/KaiLoveM/article/details/78766643
版权

无名管道

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

int main()
{
    int ret;
    pid_t pid;
    int count = 0;
    int fd[2] = {0};

    ret = pipe(fd);
    if(-1 == ret)
    {
        perror("pipe");
        exit(1);
    }

    pid = fork();
    if(-1 == pid)
    {
        perror("fork");
        exit(1);
    }
    else if (0 == pid)
    {
        sleep(1);
        count ++;
        printf("Child Process : count = %d\n",count);
        ret = write(fd[1],&count,sizeof(count));
        if(-1 == ret)
        {
            perror("write");
            exit(1);
        }
    }
    else
    {
        ret = read(fd[0],&count,sizeof(count));
        if(-1 == ret)
        {
            perror("read");
            exit(1);
        }
        count++;
        printf("Parent Process : count = %d\n",count);
        waitpid(pid,NULL,0);
    }
}

有名管道fiffowrite

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

int main()
{
    int fd,ret;
    char buf[100] = {0};

    fd = open("fifo.tmp",O_WRONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }

    while(1)
    {
        scanf("%s",buf);
        ret = write(fd,buf,strlen(buf));
        if(-1 == ret)
        {
            perror("write");
            exit(1);
        }
        if(!strncmp(buf,"bye",3))
        {
            break;
        }
    }
    return 0;
}

fiforead：

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

int main()
{
    int ret,fd;
    char buf[100] = {0};

    ret = mkfifo("fifo.tmp",O_CREAT|O_EXCL);
    if(-1 == ret)
    {
        perror("mkfifo");
        exit(1);
    }

    fd = open("fifo.tmp",O_RDONLY);
    if(-1 == fd)
    {
        perror("open");
        exit(1);
    }

    while(1)
    {
        ret = read(fd,buf,sizeof(buf));
        if(-1 == ret)
        {
            perror("read");
            exit(1);
        }
        if(!strncmp(buf,"bye",3))
        {
            break;
        }
        printf("Read From Fifo : %s\n",buf);
        memset(buf,0,sizeof(buf));
        unlink("fifo.tmp");
    }


    return 0;
}

消息队列:

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

#define MSGKEY 1234

struct msgbuf
{
    long mtype;
    char mtext[100];
};


int main()
{
    int msgid,ret;
    struct msgbuf buf;

    msgid = msgget(MSGKEY,IPC_CREAT|IPC_EXCL);
    if(-1 == msgid)
    {
        perror("msgget");
        exit(1);
    }

    while(1)
    {
        memset(&buf,0,sizeof(buf));
        scanf("%s",buf.mtext);
        buf.mtype = 1;

        ret = msgsnd(msgid,&buf,sizeof(buf) - sizeof(long),0);
        if(-1 == ret)
        {
            perror("msgsnd");
            exit(1);
        }
        if(!strncmp("bye",buf.mtext,3))
        {
            break;
        }
    }

    msgctl(msgid,IPC_RMID,NULL);

    return 0;
}

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

#define MSGKEY 1234

struct msgbuf
{
    long mtype;
    char mtext[100];
};


int main()
{
    int msgid,ret;
    struct msgbuf buf;

    msgid = msgget(MSGKEY,0);
    if(-1 == msgid)
    {
        perror("msgget");
        exit(1);
    }

    while(1)
    {
        memset(&buf,0,sizeof(buf));
        buf.mtype = 1;

        ret = msgrcv(msgid,&buf,sizeof(buf.mtext),1,0);
        if(-1 == ret)
        {
            perror("msgsnd");
            exit(1);
        }
        if(!strncmp("bye",buf.mtext,3))
        {
            break;
        }
        printf("Receive From Message : %s\n",buf.mtext);
    }


    return 0;
}

共享内存：

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

#define SHMKEY  1234
#define SHMSIZE 4096

int main()
{
    int shmid,ret;
    void *shmaddr;

    shmid = shmget(SHMKEY, SHMSIZE, IPC_CREAT | IPC_EXCL);
    if(-1 == shmid)
    {
        perror("shmget");
        exit(1);
    }

    shmaddr = shmat(shmid,NULL,0);
    if((void *)-1 == shmaddr)
    {  
        perror("shmat");
        exit(1);
    }

    strcpy(shmaddr,"chenzheshizhu");

    sleep(5);

    ret = shmdt(shmaddr);
    if(-1 == ret)
    {
        perror("shmdt");
        exit(1);
    }

    shmctl(shmid, IPC_RMID, NULL);

    return 0;
}
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>

#define SHMKEY  1234
#define SHMSIZE 4096

int main()
{
    int shmid,ret;
    void *shmaddr;
    char buf[100] = {0};

    shmid = shmget(SHMKEY, SHMSIZE,0);
    if(-1 == shmid)
    {
        perror("shmget");
        exit(1);
    }

    shmaddr = shmat(shmid,NULL,0);
    if((void *)-1 == shmaddr)
    {  
        perror("shmat");
        exit(1);
    }

    strcpy(buf,shmaddr);

    printf("Read From sharememory : %s\n",buf);

    ret = shmdt(shmaddr);
    if(-1 == ret)
    {
        perror("shmdt");
        exit(1);
    }


    return 0;
}

共享内存——结构体：

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

#define SHMKEY  1234
#define SHMSIZE 4096
#define SEMKEY  1234

union semun
{
    int              val;
    struct semid_ds *buf;
    unsigned short  *array;
    struct seminfo  *__buf;
};

int sem_p(int id)
{
    struct sembuf buf;
    int ret;

    buf.sem_num = 0;
    buf.sem_op = -1;
    buf.sem_flg = SEM_UNDO;

    ret = semop(id,&buf,1);
    if(-1 == ret)
    {
        perror("semop");
        return 1;
    }

    return 0;
}

int sem_v(int id)
{
    struct sembuf buf;
    int ret;

    buf.sem_num = 0;
    buf.sem_op = 1;
    buf.sem_flg = SEM_UNDO;

    ret = semop(id,&buf,1);
    if(-1 == ret)
    {
        perror("semop");
        return 1;
    }

    return 0;
}



int main()
{
    int shmid,ret,semid;
    void *shmaddr;
    int count = 0;
    int tmp;
    union semun union_sem;

    shmid = shmget(SHMKEY, SHMSIZE, IPC_CREAT | IPC_EXCL);
    if(-1 == shmid)
    {
        perror("shmget");
        exit(1);
    }

    shmaddr = shmat(shmid,NULL,0);
    if((void *)-1 == shmaddr)
    {  
        perror("shmat");
        exit(1);
    }

    semid = semget(SEMKEY,1,IPC_CREAT | IPC_EXCL);
    if(-1 == semid)
    {
        perror("semget");
        exit(1);
    }

    union_sem.val = 1;
    ret = semctl(semid,0,SETVAL,union_sem);

    *(int *)shmaddr = count;

    while(1)
    {
        sem_p(semid);
        tmp = *(int *)shmaddr;
        if(tmp > 1000)
        {
            break;
        }
        printf("Process 1 : count = %d\n",tmp);
        usleep(10);
        tmp++;
        *(int *)shmaddr = tmp;
        sem_v(semid);
    }


    ret = shmdt(shmaddr);
    if(-1 == ret)
    {
        perror("shmdt");
        exit(1);
    }

    sleep(1);

    shmctl(shmid, IPC_RMID, NULL);

    semctl(semid,0,IPC_RMID);
    return 0;
}
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <string.h>
#include <stdlib.h>
#include <sys/sem.h>

#define SHMKEY  1234
#define SHMSIZE 4096
#define SEMKEY  1234

union semun
{
    int              val;
    struct semid_ds *buf;
    unsigned short  *array;
    struct seminfo  *__buf;
};

int sem_p(int id)
{
    struct sembuf buf;
    int ret;

    buf.sem_num = 0;
    buf.sem_op = -1;
    buf.sem_flg = SEM_UNDO;

    ret = semop(id,&buf,1);
    if(-1 == ret)
    {
        perror("semop");
        return 1;
    }

    return 0;
}

int sem_v(int id)
{
    struct sembuf buf;
    int ret;

    buf.sem_num = 0;
    buf.sem_op = 1;
    buf.sem_flg = SEM_UNDO;

    ret = semop(id,&buf,1);
    if(-1 == ret)
    {
        perror("semop");
        return 1;
    }

    return 0;
}



int main()
{
    int shmid,ret,semid;
    void *shmaddr;
    int count = 0;
    int tmp; 

    shmid = shmget(SHMKEY, SHMSIZE, 0);
    if(-1 == shmid)
    {
        perror("shmget");
        exit(1);
    }

    shmaddr = shmat(shmid,NULL,0);
    if((void *)-1 == shmaddr)
    {  
        perror("shmat");
        exit(1);
    }

    semid = semget(SEMKEY,1,0);
    if(-1 == semid)
    {
        perror("semget");
        exit(1);
    }

    *(int *)shmaddr = count;

    while(1)
    {
        sem_p(semid);
        tmp = *(int *)shmaddr;
        if(tmp > 1000)
        {
            break;
        }
        printf("Process 2 : count = %d\n",tmp);
        usleep(10);
        tmp++;
        *(int *)shmaddr = tmp;
        sem_v(semid);
    }


    ret = shmdt(shmaddr);
    if(-1 == ret)
    {
        perror("shmdt");
        exit(1);
    }


    return 0;
}

两个程序间互发信息：

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

#define MSGKEY 1234

struct msgbuf
{
    long mtype;
    char mtext[100];
};


int main()
{
    int msgid,ret;
    struct msgbuf buf;
    pid_t pid;

    msgid = msgget(MSGKEY,IPC_CREAT|IPC_EXCL);
    if(-1 == msgid)
    {
        perror("msgget");
        exit(1);
    }

    pid = fork();
    if(-1 == pid)
    {
        perror("fork");
        exit(1);
    }

    else if(0 == pid)
    {
        while(1)
        {
         memset(&buf,0,sizeof(buf));
            scanf("%s",buf.mtext);
            buf.mtype = 1;

            ret = msgsnd(msgid,&buf,sizeof(buf) - sizeof(long),0);
         if(-1 == ret)
                {
                perror("msgsnd");
                exit(1);
                }
         if(!strncmp("bye",buf.mtext,3))
                 {
                    buf.mtype = 2;
                    ret = msgsnd(msgid,&buf,sizeof(buf) - sizeof(long),0);
                    if(-1 == ret)
                    {
                        perror("msgsnd");
                        exit(1);
                    }
            break;
                }   
            }
    }   
    else
    {
        while(1)
        {
            memset(&buf,0,sizeof(buf));
            ret = msgrcv(msgid,&buf,sizeof(buf.mtext),2,0);
            if(-1 == ret)
            {
                perror("msgrcv");
                exit(1);
            }

            if(!strncmp(buf.mtext,"bye",3))
            {
                kill(pid,SIGKILL);
                break;
            }
            printf("\t\t\t%s\n",buf.mtext);
        }
        waitpid(pid,NULL,0);
    }

    msgctl(msgid, IPC_RMID, NULL);
    return 0;
}
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/msg.h>
#include <sys/ipc.h>
#include <string.h>
#include <stdlib.h>
#include <signal.h>

#define MSGKEY 1234

struct msgbuf
{
    long mtype;
    char mtext[100];
};


int main()
{
    int msgid,ret;
    struct msgbuf buf;
    pid_t pid;

   msgid = msgget(MSGKEY, 0);
    if (-1 == msgid)
    {
        perror("msgget");
        exit(1);
    }

    pid = fork();
    if(-1 == pid)
    {
        perror("fork");
        exit(1);
    }

    else if(0 == pid)
    {
        while(1)
        {
         memset(&buf,0,sizeof(buf));
            scanf("%s",buf.mtext);
            buf.mtype = 2;

            ret = msgsnd(msgid,&buf,sizeof(buf.mtext),0);
         if(-1 == ret)
                {
                perror("msgsnd");
                exit(1);
                }
         if(!strncmp("bye",buf.mtext,3))
                 {
                    buf.mtype = 1;
                    ret = msgsnd(msgid,&buf,sizeof(buf.mtext),0);
                    if(-1 == ret)
                    {
                        perror("msgsnd");
                        exit(1);
                    }
            break;
                }   
            }
    }   
    else
    {
        while(1)
        {
            memset(&buf,0,sizeof(buf));
            ret = msgrcv(msgid,&buf,sizeof(buf.mtext),1,0);
            if(-1 == ret)
            {
                perror("msgrcv");
                exit(1);
            }

            if(!strncmp(buf.mtext,"bye",3))
            {
                kill(pid,SIGKILL);
                break;
            }
            printf("\t\t\t%s\n",buf.mtext);
        }
        waitpid(pid,NULL,0);
    }


    return 0;
}
KaiLoveM
关注
C#【必备技能篇】两个程序（进程间）通信,传递消息给其它窗口
星Yeah 的博客
10-12 8342
C#【必备技能篇】两个程序（进程间）通信,传递消息给其它窗口
跨平台进程间通信源码
04-17
跨平台进程间通信解决方案,可以向多个进程发送消息,windows/linux上实测通过 ...
关于进程间互发信息
yacper的专栏
01-05 674
　　想一想,在平时的处理程序的时候,我们都是在一个进程中进行处理,所以,在处理字符串的时候,我们都不用考虑太多的问题,处理什么样的数据和数据的发送都会在同一个进程中进行。　　但是,假如要你负责一个程序要在两个不同的进程中交换数据,你会怎么办,你要想怎样做,一般的做法是这样,自定义一个消息,然后你就把这个数据放在这个消息附带的参数WPARAM wParam 与 LPARAM lP
Linux进程间通信源码剖析，共享内存(mmap)
LYJ个人博客，记录技术、八卦、生活，分享各种心得，期待与朋友们一同进步
12-21 3111
<br />来自：http://blog.csdn.net/dancing999/archive/2008/01/13/2042473.aspx<br /> <br />范例1：两个进程通过映射普通文件实现共享内存通信<br />范例1包含两个子程序：map_normalfile1.c及map_normalfile2.c。编译两个程序，可执行文件分别为map_normalfile1及map_normalfile2。两个程序通过命令行参数指定同一个文件来实现共享内存方式的进程间通信。map_normalfil
Linux两个进程互相发送消息,Linux进程间通信（消息队列，信号量，共享内存）...
weixin_34220317的博客
04-30 879
写在前面不得不说，Deadline果真是第一生产力。不过做出来的东西真的是不堪入目，于是又花了一早上重写代码。实验内容进程通信的邮箱方式由操作系统提供形如 send()和 receive()的系统调用来支持，本实验要求学生首先查找资料了解所选用操作系统平台上用于进程通信的系统调用具体形式，然后使用该系统调用编写程序进行进程间的通信，要求程序运行结果可以直观地体现在界面上。在此基础上查找所选用操作系...
进程间通信（附进程同步源码）
时间流浪者
05-13 796
摘要： 进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。另外，系统空间是“公共场所”，各进程均可以访问，所以内核也可以提供这样的条件。此外，还有双方都可以访问的外设。在这个意义上，两个进程当然也可以通过磁盘上的普通文件交换信息，或者通过“注册表”或其它数据库中的某些表项和记录交换信息。广义上这也是进程间通信的手段，但是一般都不把这算作“进程间通信”。 简介： 进程间通信（IPC，Interprocess communication）是一...
在两个执行程序间进行数据通信.rar_两个程序通信_数据通信_程序间通信
09-22
在两个程序之间进行数据通信，可以采用多种方法，如管道（Pipe）、共享内存、消息队列、套接字（Socket）以及文件映射等。 1. **管道通信**：管道是一种简单的单向通信方式，它创建一个共享文件，两个进程可以通过...
VC++实现两个进程间的通信--DLL
11-12
本示例中的"VC++实现两个进程间的通信--DLL"是一个利用DLL来实现进程间通信（IPC，Inter-Process Communication）的项目。下面将详细阐述相关知识点： 1. DLL基础： - DLL文件是一种包含可由多个执行文件同时使用...
python两个程序之间实现通信_python多进程间通信与接口间调用
weixin_33274593的博客
12-29 3866
最近在写一个小机器人的小项目，将比较耗时且繁琐的任务交由机器人处理，解放出人力资源。机器人功能已完成。但是使用由主系统推送信息，到机器人执行完成，再返回主系统结果，这样的单进程模式，显然不合理，于是想到了利用python的多进程模式。flow.png多进程多进程使用python内置的multiprocessing模块，它提供了一个Process类来代表一个进程对象。创建子进程时，只需要传入一个执行...
python实现进程间通信简单实例
12-25
本文实例讲解了python实现两个程序之间通信的方法，具体方法如下： 该实例采用socket实现，与socket网络编程不一样的是socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)的第一个参数是socket.AF_UNIX 而不是 ...
c# 两个进程操作一个txt,互发信息均可实现
04-06
c# 两个进程操作一个txt,互发信息均可实现
进程间通信
03-06
七种进程间通信方式： 一.无名管道（ pipe ） 二.有名管道（ fifo ） 三.共享内存 ( shared memory ) 四.信号 ( sinal ) 五.消息队列 ( message queue ） 六.信号量 ( semophore ) 七.套接字 ( socket ) 进程间通信之无名管道（pipe） 进程间通信之有名管道（fifo） 进程间通信之共享内存 shared memory 进程间通信之信号 sinal 进程间通信之消息队列 ( message queue ） 进程间通信之信号量( semophore ) 进程间通信之套接字( socket )
进程间通信之套接字( socket )——完整代码
01-24
进程间通信之套接字( socket ) 网络间通信 七种进程间通信方式： 一.无名管道（ pipe ） 二.有名管道（ fifo ） 三.共享内存 ( shared memory ) 四.信号 ( sinal ) 五.消息队列 ( message queue ） 六.信号量 ( semophore ) 七.套接字 ( socket ) 以上七种进程间通信的完整代码，皆可以在我的资源列表中获取下载： 资源列表：http://download.csdn.net/user/qiulanzhu
进程通信，互发消息 mfc
11-04
主要是是两个程序互相获得对方句柄。主要是将得到的句柄转换为字符串，然后在接受方再转换为句柄。自己测试用的，代码有些乱，
源码分析(二) 进程间通信机制
weixin_30491641的博客
06-27 96
注：EOS代码版本：4.0 一.EOS进程的基本介绍： EOS项目中主要包括nodeos,cleos,keosd这三个进程，各自的交互大抵如下： nodeos: 节点运行的进程。通信包括两个方面： 节点与节点的通信，主要为数据的同步。 节点与cleos的通信。 cleos: EOS客户端进程。主要通信包括两个方面： cl...
Nginx源码分析与实践---进程间通信机制（套接字）
ZX714311728的博客
03-25 1371
在上一篇中，我们看到了nginx共享内存方式的进程间通信。这次我们看下nginx使用套接字的进程间通信方式。 同样的几个问题： 1.什么时候需要使用套接字方式的进程间通信机制呢？ 举个栗子：我们知道nginx有master进程和worker进程，那么master进程是如何向worker进程发送消息的呢？worker进程又是如何接收master发送过来的消息呢？答案就是使用套接字。注意
两个进程之间的通信
Genten程泽翔的博客
11-17 909
下面写一下我做的一个两个App进程之间的通信方式，用一个简单的例子来体现    相当于一个加法计算器：     首先这里需要创建两个modle,一个是客户端App，一个是服务端App    这里用的是dataBinding的写法，所以需要在grid中写个配置                                 还有一个自己封装的工具包：   TypeCast:
Linux--进程间通信之命名管道（代码实现）
哥不帅但很坏的博客
05-15 1122
一、概念 Linux中的管道，可以分为匿名管道(同常就称为管道),命名管道。 上一篇博客讲的就是匿名管道：Linux进程通信之管道，读者有兴趣可以看一下，本篇博客将的是命名管道。 管道的不足之处，只能用于有血缘关系的进程。命名管道(FIFO)的提出就突破了管道的限制，管道提供了路径名与之关联，以FIFO的文件形式存储于文件系统中。命名管道可以被不同进程以不同的方式方法调用（可以跨权限、跨语言
两个进程进行通信的简单例子
weixin_30908707的博客
08-13 128
add2.c 编译后生成执行文件add2 一个简单的加法运算器 通过标准输入端获取参数 标准输出端返回结果 #include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <string.h>#define MAXLINE 1024int main(int argc,char *a...
Linux进程间通信测试程序详解与实践
资源摘要信息:"Linux进程间通信测试程序.zip_linux_linux 程序_linux 网络_linux网络_进程间通信" 本资源主要涉及Linux操作系统中的进程间通信（IPC）机制。进程间通信是操作系统中不同进程之间交换信息的手段和...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值