撸代码--linux进程通信(基于共享内存)

1.实现亲缘关系进程的通信,父写子读

思路分析:1)首先我们须要创建一个共享内存。

2)父子进程的创建要用到fork函数。fork函数创建后,两个进程分别独立的执行。

3)父进程完毕写的内容。同一时候要保证子进程退出后,在删除共享内存。

4)子进程完毕读的内容。

效果展示: 

              

代码展示:

         

 #include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <errno.h>

int main()
{//父子进程 操作共享内存
//先创建共享内存  父进程对共享内存写 子进程对共享内存读
        int flag;
        flag=shmget(IPC_PRIVATE,4096,0600|IPC_CREAT);
        //创建一个共享内存  然后返回标示符

        char buf[]={"I am your father\n"};
        char s[123];
        if(fork()!=0)
        {//父进程完毕对共享内存的写
           char *f;
           f=(char *)shmat(flag,NULL,0);//连接了父进程和共享内存 返回指针 指向
           //内存的第一个字节
           memset(f,‘\0‘,4096);//这时候能够操作f
           strncpy(f,"I am you father",16);//写入内容

           printf("parent %d Write buf is %s\n",getpid(),f);
           wait(NULL);//等待子进程
           shmctl(flag,IPC_RMID,0);//删除共享 内存
           exit(0);
        }
        else
        {
           char *fp;
           sleep(3);//让父进程有时间往里面写
           fp=(char *)shmat(flag,NULL,0);//子进程跟其连接 然后返回给字符指针
           printf("child pid is %d,Read buf is %s\n",getpid(),fp);
           exit(0);
        }
}

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

2.实现非亲缘关系的通信。(两个进程对共享内存的值进行改动)

思路分析:1)首先我们须要创建一个共享内存。

2)两个进程要採取锁的方式訪问共享内存的值。

效果展示:

代码展示:      

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

//写进程不断的写 然后要推断当前内存中的锁是开闭状态
struct t
{
        int user_now;//定义一个锁
        int val;
};

int main()
{
        int flag;
        flag=shmget((key_t)1234,4096,0600|IPC_CREAT);

        struct t *tt;
        tt=(struct t*)shmat(flag,NULL,0);//拿到内存
        tt->user_now=0;
        while(1)
        {
          if(tt->user_now==0)
                {//假设0 锁开了 那么设置值
                 tt->val=1;
                 printf("I am write, the value is %d\n",tt->val);                                        tt->user_now=1;//加上锁。

}
         sleep(1);
        }
        shmdt((void *)tt);
        return 0;

}

写进程2:

<pre name="code" class="objc">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>

//写进程不断的写 然后要推断当前内存中的锁是开闭状态
struct t
{
        int user_now;//定义一个锁
        int val;
};

int main()
{
        int flag;
        flag=shmget((key_t)1234,4096,0600|IPC_CREAT);

        struct t *tt;
        tt=(struct t*)shmat(flag,NULL,0);//拿到内存
        tt->user_now=0;
        while(1)
        {
          if(tt->user_now==1)
                {//假设0 锁开了 那么设置
                 tt->val=2;
                 printf("I am write2, the value is %d\n",tt->val);                               tt->user_now=0;//加上锁。
                }
          sleep(1);
        }
        shmdt((void *)tt);
        shmctl(flag,IPC_RMID,0);
        return 0;

}

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

3.程序间的对话(AB进程能够实现对话  仅仅能够实现A进程不断写 B进程不断读)

思路分析:1)首先我们须要创建一个共享内存。

2)建立两个进程,A,B。

A进程完毕接受键盘的输入,然后放在共享内存中。

3)B进程拿出共享内存的数据。然后显示出来。

效果展示:   

                 

代码展示:

A进程

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

//写进程不断的写 然后要推断当前内存中的锁是开闭状态
struct t
{
        int user_now;//定义一个锁
        char buf[1024];
};

int main()
{
        int flag;
        flag=shmget((key_t)1234,4096,0600|IPC_CREAT);

        struct t *tt;
        tt=(struct t*)shmat(flag,NULL,0);//拿到内存
        tt->user_now=0;
        while(1)
        {
          if(tt->user_now==0)
                {//假设0 锁开了 那么设置值
                 read(STDIN_FILENO,tt->buf,1024);
                 //将键盘输入的放在共享内存的buf中
                 tt->user_now=1;
                }
        // memset(tt->buf,0,sizeof(tt->buf));
         sleep(1);
        }
        shmdt((void *)tt);
        return 0;

}<strong>
</strong>

B进程

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

//写进程不断的写 然后要推断当前内存中的锁是开闭状态
struct t
{
        int user_now;//定义一个锁
        char buf[1024];
};

int main()
{
        int flag;
        flag=shmget((key_t)1234,4096,0600|IPC_CREAT);

        struct t *tt;
        tt=(struct t*)shmat(flag,NULL,0);//拿到内存
        tt->user_now=0;
        while(1)
        {
          if(tt->user_now==1)
                {//假设0 锁开了 那么设置值
                 write(STDOUT_FILENO,tt->buf,strlen(tt->buf));
                 memset(tt->buf,0,sizeof(tt->buf));
                 tt->user_now=0;
                }
          sleep(1);
        }
        shmdt((void *)tt);
        shmctl(flag,IPC_RMID,0);
        return 0;

}

时间: 2024-11-05 06:13:20

撸代码--linux进程通信(基于共享内存)的相关文章

linux 进程通信之 共享内存

共享内存是被多个进程共享的一部分物理内存.共享内存是进程间共享数据的一种最快的方法,一个进程向共享内存区域写入了数据,共享这个内存区域的所有进程就可以立刻看到其中的内容. 关于共享内存使用的API key_t ftok(const char *pathname, int proj_id); #在IPC中,我们经常用一个 key_t 的值来创建或者打开 信号量,共享内存和消息队列.这个 key_t 就是由ftok函数产生的. pathname:指定的文件名,该文件必须是存在而且可以访问 proj_

Linux 进程通信(共享内存区)

共享内存是由内核出于在多个进程间交换信息的目的而留出的一块内存区(段). 如果段的权限设置恰当,每个要访问该段内存的进程都可以把它映像到自己的私有地址空间中. 如果一个进程更新了段中的数据,其他进程也立即会看到更新. 由一个进程创建的段,也可以由另一个进程读写. 每个进程都把它自己对共享内存的映像放入自己的地址空间. 创建共享内存区 int shmget(key_t key,size_t size,int shm-flg); 参数key既可以是IPC_PRIVATE(IPC_PRIVATE表示让

linux进程通信之共享内存

共享内存同意两个或多个进程共享一给定的存储区,由于数据不须要来回复制,所以是最快的一种进程间通信机制.共享内存能够通过mmap()映射普通文件(特殊情况下还能够採用匿名映射)机制实现,也能够通过系统V共享内存机制实现.应用接口和原理非常easy,内部机制复杂.为了实现更安全通信,往往还与信号量等同步机制共同使用.以下主要介绍系统V共享内存机制,主要用到的系统API包含: 1.shmget函数:获得一个共享内存标识符. int shmget(key_t key, size_t size, int 

进程通信之共享内存

共享内存 共享内存就是允许两个不相关的进程访问同一个逻辑内存.共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式.不同进程之间共享的内存通常安排为同一段物理内存.进程可以将同一段共享内存连接到它们自己的地址空间中,所有进程都可以访问共享内存中的地址,就好像它们是由用C语言函数malloc分配的内存一样.而如果某个进程向共享内存写入数据,所做的改动将立即影响到可以访问同一段共享内存的任何其他进程. 共享内存并未提供同步机制,也就是说,在第一个进程结束对共享内存的写操作之前,并无自

进程通信之共享内存篇

共享内存原理示意图 shmget函数语法: shmat函数语法 shmdt函数语法 代码分析: /* shmem.c */ #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #define BUFFER_SIZE 2048 int main

linux 进程学习笔记-共享内存

如果能划定一块物理内存,让多个进程都能将该内存映射到其自身虚拟内存空间的话,那么进程可以通过向这块内存空间读写数据而达到通信的目的.另外,和消息队列不同的是,共享的内存在用户空间而不是核空间,那么就不存在“用户空间和内核空间之间数据复制”的问题,这会减少不少开销. 由于不同进程都可能向同一个空间读写数据,所以其需要一些同步机制来防止混乱,可以使用的机制有“信号量”“文件锁”等. 共享内存有mmap和System V Shared Memory, 下面说的是后者. 创建或打开共享内存: int s

进程通信(共享内存)

共享内存: 用于进程间数据传输,是最高效的,并不提供同步,互斥  shm.h:   1 #include<stdio.h>   2 #include<stdlib.h>   3 #include<sys/ipc.h>   4 #include<sys/shm.h>   5 #include<string.h>   6 #include<sys/wait.h>   7 #include <unistd.h>   8    9

linux进程间的通信(C): 共享内存

一.共享内存介绍 共享内存是三个IPC(Inter-Process Communication)机制中的一个. 它允许两个不相关的进程访问同一个逻辑内存. 共享内存是在两个正在进行的进程之间传递数据的一种非常有效的方式. 大多数的共享内存的实现, 都把由不同进程之间共享的内存安排为同一段物理内存. 共享内存是由IPC为进程创建一个特殊的地址范围, 它将出现在该进程的地址空间中. 其他进程可以将同一段共享内存连接它们自己的地址空间中. 所有进程都可以访问共享内存中的地址, 就好像它们是由mallo

linux进程间的通信之 共享内存

一.共享内存介绍 共享内存是三个IPC(Inter-Process Communication)机制中的一个. 它允许两个不相关的进程访问同一个逻辑内存. 共享内存是在两个正在进行的进程之间传递数据的一种非常有效的方式. 大多数的共享内存的实现, 都把由不同进程之间共享的内存安排为同一段物理内存. 共享内存是由IPC为进程创建一个特殊的地址范围, 它将出现在该进程的地址空间中. 其他进程可以将同一段共享内存连接它们自己的地址空间中. 所有进程都可以访问共享内存中的地址, 就好像它们是由mallo