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

最新推荐文章于 2024-02-04 10:34:32 发布
最新推荐文章于 2024-02-04 10:34:32 发布
阅读量1.1k 收藏 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
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
基于C语言实现的两种常见页面置换算法（OPT，LRU）
04-02
针对一个虚拟存储区和内存工作区,编程序演示下述算法的具体实现过程，并计算访问命中率。要求设计主界面以灵活选择某算法，且以下算法都要实现 (1)最佳淘汰算法（OPT） (2)最近最少访问页面算法（LRU） 2.要有体现算法比较的程序输出，比如：缺页率和页面置换次数等。 3.采用固定分配局部置换，且可以在程序中实现块数重新分配。 具有抖动判断和Belady异常判断机制 根据设计要求实现对页面置换算法的模拟以及 进程状态转换的模拟。 1.根据自己输入 物理块数量,访问页面总数,要访问的页面号,  2.然后选择所需的置换算法 OPT,LRU 二选一. 计算过程,并得出 缺页次数,缺页率,置换次数,命中率的结果; 3.进行虚拟存储算法设计分析。
【操作系统】进程间的通信——信号
半生瓜のblog
08-22 628
什么是信号? 信号是给程序提供一种可以处理异步事件的方法，它利用**软件中断**来实现。 我们无法自定义信号，所有信号都是系统预定义的。
写出三种进程间通信的代码示例
最新发布
weixin_60180793的博客
02-04 449
【代码】写出三种进程间通信的代码示例。
C语言进程间通信
Hard struggle
09-12 7926
进程间通信： 1： 资源共享 ---  2： 数据传输 --- 发送接受信息 3： 通知事件 --- 信号 4： 进程控制 --- 控制进程状态转换 比较古老： 无名管道(PIPE) 有名管道（FIFO ，named pipe） 信号(signal) SYSTEM V IPC 信号量(Sem) 共享内存(shm) 消息队列(Msg) BSD  套接字（Soc
有名管道FIFO，进行两个独立进程的双向通信
m0_72737896的博客
08-21 538
进程1中子进程用来发送数据给进程2中的子进程，进程2中的父进程发送数据给进程1中的父进程。为实现两个独立进程之间的通信，我们需要给两个独立的进程创建子进程和父进程。发送和接收过程中运用到文件的读写函数 write（）和read（）。利用fork（）函数创建进程的子进程和父进程。
学习笔记——进程间通信之信号详解
打不倒的程序猿
05-29 685
重点来啦！！！ 对于Linux来说，信号实际上是软中断，许多重要的程序都需要处理信号。信号（Signals ）是Unix系统中使用的最古老的进程间通信的方法，它为Linux提供了一种处理异步事件的方法，所以也是进程间惟一的异步通信方式。 信号简介 信号名称 每一个信号都有自己的名字和编号，且都以SIG开头。 信号定义在<signal.h>头文件中，信号名都定义为正整数。 使用kill -l来查看信号的名字和编号，信号是从1开始编号的，不存在0号信号。 kill对于信号0又特殊的应用。 使
多线程编程时的信号处理
fang0625的专栏
01-11 2110
1. 默认情况下，信号将由主进程接收处理，就算信号处理函数是由子线程注册的 2. 每个线程均有自己的信号屏蔽字，可以使用sigprocmask函数来屏蔽某个线程对该信号的响应处理，仅留下需要处理该信号的线程来处理指定的信号。 3. 对某个信号处理函数，以程序执行时最后一次注册的处理函数为准，即在所有的线程里，同一个信号在任何线程里对该信号的处理一定相同 4. 可以使用pthread_kill对指定
一文搞懂「信号」和「信号集」
阿东的学习记录
03-12 3292
文章目录信号是啥信号相关函数killraiseabortalarmsetitimersignal信号集信号集相关函数sigemptysetsigfillsetsigaddsetsigdelsetsigismembersigprocmasksigpendingsigactionSIGCHLD 信号 信号是啥 信号是 Linux 进程间通信的最古老的方式之一，是事件发生时对进程的通知机制，有时也称之为软件中断，它是在软件层次上对中断机制的一种模拟，是一种异步通信的方式。信号可以导致一个正在运行的进程被另一个正在
C++进程间通信的多种方式及实现
qq_43119867的博客
05-06 5944
多进程通信
进程间的七种通信方式之-----（五）共享内存(share memory)
weixin_42538789的博客
04-25 1028
进程间的7种通信方式 之（三）共享内存 共享内存是一种最为高效的进程间通信方式，进程可以直接读写内存，而不需要任何数据的拷贝 为了在多个进程间交换信息，内核专门留出了一块内存区，可以由需要访问的进程将其映射到自己的私有地址空间 进程就可以直接读写这一内存区而不需要进行数据的拷贝，从而大大提高的效率。 示例代码 #include <stdio.h> #include <string.h> #include <stdlib.h> #include <unistd.h&g
socket 实现进程间通信
06-16
实现三个进程用socket完成进程间通信。用到socket 的本地通信，与select（）函数，信号，还有在一个进程中完成另外一个进程的重新启动
进程间通信(消息传递机制)
09-14
进程间通信基本的基本知识 postmessage和sendmessage
操作系统进程间通信实验报告（源码）
11-18
该实验报告详细描述了进程间通信的实现原理，使用管道以及信号实现进出那个间通信，附有源代码实现。
利用Socket原理Java实现双方通信
04-05
利用Socket原理java实现双方实时通信。只要将代码中客户端的回环地址更改成通信的另一方的IP地址，再把服务器端程序在此IP地址上编译运行即可。在服务端开启后，再使本机的客户端程序运行即可实现双方通信。
进程间通讯（两个应用程序如何通讯）C#源代码.rar
06-18
进程间通讯（两个应用程序如何通讯）C#源代码 消息传递 message-passing：通过操作系统的相应系统调用进行消息传递通讯。分为直接和间接两种： 直接通信方式：点到点的发送 Send (DestProcessName, Message)； ...
python实现进程间通信简单实例
12-25
本文实例讲解了python实现两个程序之间通信的方法，具体方法如下： 该实例采用socket实现，与socket网络编程不一样的是socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)的第一个参数是socket.AF_UNIX 而不是 ...
进程间通过共享内存实现通信的方法
07-26
介绍了线程和进程之间通过共享内存实现通信的方法，包含了具体事例和源码
c#共享内存demo-两个进程间通过共享内存实现通信
02-18
分为3个工程:proA,proB,ShareMemLib 其中proA,proB是用wpf写的两个模拟进程程序 ShareMemLib将共享内存代码封装成lib，定义了发送者和监听者 两个进程在实例化Share...至此成功完成了两个进程间通过共享内存实现通信
用Ubuntu编写程序，共享内存实现两个进程间的通信
05-26
共享内存是一种进程间通信(IPC)的方法，可以让不同的进程共享同一块内存空间，从而实现数据的交换。下面是一个简单的例子，展示了如何在Ubuntu上使用共享内存实现进程间通信。 首先，我们需要创建一个共享内存区域...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值