Linux进程通信(无名管道，有名管道，共享内存)的实现

最新推荐文章于 2024-02-05 19:36:03 发布

2359_God

最新推荐文章于 2024-02-05 19:36:03 发布

阅读量1.3k

点赞数

分类专栏： C++

本文链接：https://blog.csdn.net/szqsdq/article/details/48523231

版权

C++ 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

Linux进程的通信有很多种方式，比如无名管道，有名管道，共享内存，Android进程通信采用的确是Binder机制~~~

在学习进程通信之前先学习一下System，Fork，Execive的机制，System调用的是另一个进程跟自己毫无关系用的比较少。Fork创建的是父子进程，父进程的内存会被复制到

字进程的内存空间区别就是PID的不同。Execive调用的进程就会保留内存空间但是执行的是调用程序的代码。

首先看一下这三种创建进程的方法区别：

Execive:

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



int main(void)
{

  printf("start\n");
  char* args[] = {"/bin/ls","-l",NULL};
  execve("/bin/ls",args,NULL);
  printf("end\n");
  return EXIT_SUCCESS;
}

执行到execive是内存空间会被/bin/ls占据，后面的打印语句就会被取消没有打印出来

重点看一下Fork机制：

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



int main(int arg,char*args[])
{
  printf("begin\n");
  pid_t child = fork();
  if(child == -1)
  {
    return -1;
  }
  if(child == 0)
  {
    printf("is child\n");

    printf("child  pid = %d\n",getpid());


  }else
  {
     printf("is parent\n");

     printf("parent i pid = %d\n",getpid());


  }
  printf("end\n");

  return EXIT_SUCCESS;
}
~

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



int main(int arg,char*args[])
{

  int status;
  pid_t child = fork();
  if(child == -1)
  {
    return -1;
  }
  if(child == 0)
  {
    printf("child start\n");
    sleep(5);
    printf("child end\n");
    return 100;

  }else
  {
     printf("parent start\n");
     wait(&status);
     printf("status = %d\n",WEXITSTATUS(status));
     printf("parent end");


  }
  printf("end\n");

  return EXIT_SUCCESS;
}
~

父进程必须使用wait等待子进程结束掉才能关闭掉，通过status获得返回值，如果子进程死掉，父进程活着，子进程就会变成僵尸进程占据资源

nt main(int arg,char*args[])
{

  int status;
  pid_t child = fork();
  if(child == -1)
  {
    return -1;
  }
  if(child == 0)
  {
    exit(0);

  }else
  {
     printf("parent start\n");
     sleep(30);
     printf("parent end");


  }
  printf("end\n");

  return EXIT_SUCCESS;
}
~                                                                                                                                   
~                                                                                                                                   
~                                                                                                                                   
~

这个时候通过ps aux可以看到子进程已经僵死

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

int main(int arg,char*args[])
{

  close(STDOUT_FILENO);
  open("/dev/pts/1",O_WRONLY);
  pid_t child = fork();
  if(child == -1)
  {
    return -1;
  }
  if(child == 0)
  {
    char* args[] = {"/bin/ls","-l",NULL};
    execve("/bin/ls",args,NULL);

  }else
  {
    exit(0);

  }
  printf("end\n");

  return EXIT_SUCCESS;
}
~                                                                                                                                   
~                                                                                                                                   
~                                                                                                                                   
~                                                                                                                                   
~                                                                                                                                   
~                                                                                                                                   
~

这个案例会发现父子进程共享文件描述符，然后execve打印在控制台/dev/pts/1上

OK 理解了父子进程进程创建的方式开始讲一下进程通信：

管道是管道文件，无名管道限于父子进程之间的通信，有名管道是任何两个进程的通信，共享内存也是。

无名管道通信如下：

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

int main(int arg,char* args[])
{
  int fd[2];
  char message[100];
  int len;
  pipe(fd);
  memset(message,0,sizeof(message));
  int pid = fork();
  if(pid == 0)
  {
    close(fd[1]);
    while((len = read(fd[0],message,sizeof(message))) > 0 )
    {
       write(STDOUT_FILENO,message,len);
    }
    close(fd[0]);

  }else
  {
    close(fd[0]);
    strcpy(message,"shaozhongqi come from nanjing");
    write(fd[1],message,sizeof(message));
    close(fd[1]);
    waitpid(pid,NULL,0);
  }

  return EXIT_SUCCESS;
}

通过pipe()方法创建无名管道，父进程写数据，子进程读数据直到管道文件被关闭

有名管道需要通过命令mkfifo创建

案例如下：

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int main(int arg,char* args[])
{
  char buf[100];
  int len;
  int fd = open("testfifo",O_RDONLY);
  memset(buf,0,sizeof(buf));
  while((len = read(fd,buf,sizeof(buf))) > 0)
  {
     write(STDOUT_FILENO,buf,strlen(buf));
     memset(buf,0,sizeof(buf));
  }
  return EXIT_SUCCESS;
}

打开管道文件testfifo,然后从管道读数据

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


int main(int arg,char* args[])
{

  char buf[100];
  int fd = open("testfifo",O_WRONLY);
  memset(buf,0,sizeof(buf));
  while(1)
  {
    read(STDIN_FILENO,buf,sizeof(buf));
    if(buf[0] == '0')
    {
      close(fd);
      break;
    }else
    {
      write(fd,buf,strlen(buf));
      memset(buf,0,sizeof(buf));
    }

  }

  return EXIT_SUCCESS;
}
~                                                                                                                                   
~                                                                                                                                   
~                                                                                                                                   
~

打开管道文件写数据直到这完成了单向的管道读写数据

下面将一些共享内存首先通过

#include <sys/types.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ipc.h>
#include <sys/shm.h>

int main(int arg,char* args[])
{

  int shmid = shmget(IPC_PRIVATE,1024,0666);
  if(shmid < 0)
  {
    printf("failure\n");
  }else
  {
    printf("id:%d\n",shmid);
  }
  return EXIT_SUCCESS;
}

然后通过命令ipcs -m 查看共享内存的信息返回共享内存的id

下面就是进程在自己内存开辟一块内存与共享内存进行关联，当进程在自己的内存中读写数据会同步到共享内存中(进程是不能直接操作共享内存的)

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

int main(int arg,char* args[])
{
  char* shmbuf;
  int shmid = 0;
  if(arg < 2)
  {
    return -1;
  }

  shmid = atoi(args[1]);
  shmbuf = shmat(shmid,0,0);
  if(atoi(args[2]) == 1)
  {
     //read
     printf("%s\n",shmbuf);

  }else if(atoi(args[2]) == 2)
  {
     //write
     scanf("%s\n",shmbuf);

  }
  shmdt(shmbuf);
  return EXIT_SUCCESS;
}
~                                                                                                                                                            
~

Ok 基本学习到此

2359_God

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Linux进程通信(无名管道，有名管道，共享内存)的实现

Linux进程的通信有很多种方式，比如无名管道，有名管道，共享内存，Android进程通信采用的确是Binder机制~~~ 在学习进程通信之前先学习一下System，Fork，Execive的机制，System调用的是另一个进程跟自己毫无关系用的比较少。Fork创建的是父子进程，父进程的内存会被复制到字进程的内存空间区别就是PID的不同。Execive调用的进程就会保留内存空间但是执
复制链接

扫一扫