进程间通信IPC

最新推荐文章于 2024-03-15 14:45:21 发布

薛定谔的猫的┗|｀O′|┛ 嗷~~

最新推荐文章于 2024-03-15 14:45:21 发布

阅读量135

点赞数

分类专栏： Linux 文章标签： c语言 ipc 多进程

本文链接：https://blog.csdn.net/qq_36737680/article/details/118726950

版权

Linux 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

IPC

IPC（Inter-Process Communication，进程间通信）。进程间通信是指两个进程的数据之间产生交互。

1、管道

1.1基本概念

管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。

本质是一个伪文件（实为内核缓冲区）。
有两个文件描述符，一个表示读端(fd[1])，一个表示写端(fd[0])。
规定数据从管道的写端流入，从读端流出。
双向半双工。

原理：管道实为内核使用环形队列机制，借助内核缓冲区（4k）实现。

缺点：

数据只能自己读不能自己写。
数据一旦被读走，便不存在管道中，不可反复读取。
半双工，数据只能在一个方向上流动。
只能在有公共祖先的进程间使用。

查看系统用户所有限制值的命令：ulimit -a

root@iZwz94euuu9omhoocm3l5uZ:~# ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 7725
max locked memory       (kbytes, -l) 65536
max memory size         (kbytes, -m) unlimited
open files                      (-n) 65535
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 7725
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

pipe size = 512bytes * 8 = 4KBytes ,512bytes为磁盘的一个扇区大小。

1.2pipe函数

#include <sys/wait.h>
int pipe(int pipefd[2]);

参数：pipefd[0]为读端，pipefd[1]为写端
返回值：成功：0；失败：-1，设置errno

1.3例子

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/wait.h>
int main(void)
{
  int fd[2];
  pid_t pid;

  int ret = pipe(fd);
  if(ret == -1)
  {
    perror("pipe error:");
    exit(1);
  }
  pid = fork();
  if(pid == -1)
  {
    perror("fork error:");
    exit(1);
  }
  else if(pid == 0) // 子进程 读数据
  {

    char buf[1024] = {0};
    close(fd[1]);
    ret = read(fd[0], buf, sizeof(buf));
    if(ret == 0)
    {
      printf("----\n");
    }
    write(STDOUT_FILENO, buf, ret);
    close(fd[0]);
  }
  else // 父进程 写数据
  {
    close(fd[0]);
    char *data = "hello pipe\n";
    printf("len = %ld\n", sizeof(data));
    write(fd[1], data, strlen(data));
    wait(NULL); // 阻塞回收子线程资源，避免子进程成为僵尸进程
    close(fd[1]);

  }

  return 0;
}

1.4读写管道的特点

读管道：
管道中有数据，read返回实际读到的字节数。
管道中无数据：
- 管道写端被全部关闭，read返回0 (好像读到文件结尾)
- 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)
写管道：
- 管道读端全部被关闭，进程异常终止(也可使用捕捉SIGPIPE信号，使进程不终止)
- 管道读端没有全部关闭：
  - 管道已满，write阻塞。
  - 管道未满，write将数据写入，并返回实际写入的字节数。

2、共享内存

2.1基本概念

共享内存就是映射一段能被其它进程所访问的内存，这段共享内存由一个进程创建，但其它的多个进程
都可以访问，使得多个进程可以访问同一块内存空间。

特点：

共享内存是最快的一种 IPC，因为进程是直接对内存进行存取。
管道和消息队列等通信方式，需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次：一次从输入文件到共享内存，另一次从共享内存到输出文件。
因为多个进程可以同时操作，所以需要进行同步。
一般和信号量一起使用，信号量用来同步对共享内存的访问。

2.2相关函数

创建共享内存映射：

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

参数：

addr：建立映射区的首地址，由Linux内核指定。使用时，写NULL即可。
length：要创建映射区的大小。
prot：映射区权限 PORT_READ 、PORT_WRITE、 PORT_READ | PORT_WRITE。
flags：标志位参数（常用于设定更新物理地址、设置共享、创建匿名映射区）。

MAP_SHARED：将映射区所做的操作反映到物理设备（磁盘）上。

MAP_PRIVATE：映射区所做的修改不会反映到物理设备上。

fd：用来建立映射区的文件描述符。
offset：映射文件的偏移（一定要是4k的整数倍）。

返回值：成功返回创建的映射区首地址；失败返回MAP_FAILED宏。

解除共享内存映射：

#include <sys/mman.h>
int munmap(void *addr, size_t length);

参数：

addr：映射区的首地址。
length：映射区的大小。

返回值：成功返回0；失败返回-1。

一定要注意：

创建映射区的时候，隐含着一次对映射文件的读操作。
当MAP_SHARED时，要求：映射区的权限应 <= 文件打开的权限（出于对映射区的保护）。而MAP_PRIVATE则无所谓，因为mmap 中的权限是对内存的限制。
映射区的释放和文件关闭无关。只要映射成功，文件可以立刻关闭。
特别注意：当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际的大小！！！mmap使用时常出现总线错误，通常是因为共享文件存储空间大小引起的。
munmap传入的地址一定要是mmap返回的地址。坚决杜绝指针++操作。
如果文件偏移量必须为4k的整数倍。
mmap创建的映射区出错概率非常高，一定要检查返回值，确保映射区建立成功后才进行后续操作。

2.3例子

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

#define MY_MMAP_SIZE 20
#define MY_MMAP_FILE "temp"

int main(void)
{
    char *p = NULL;
    pid_t pid;

    int fd;
    fd = open(MY_MMAP_FILE, O_RDWR|O_CREAT|O_TRUNC, 0644);
    if(fd < 0){
        perror("open error");
        exit(1);
    }
    unlink(MY_MMAP_FILE);        //删除临时文件目录项
    ftruncate(fd, MY_MMAP_SIZE);
    p = (char *)mmap(NULL, MY_MMAP_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if(p == MAP_FAILED) { // 注意，不是 p == NULL
        perror("mmap error");
    exit(1);
    }
    close(fd);                   //映射区建立完毕,即可关闭文件

    pid = fork();                               //创建子进程
    if(pid == 0){
       char *data = "child hello!\n";
        strncpy(p, data, strlen(data) + 1);
       // *p = 1234;
        printf("son, *p = %s\n", p);
    } else {
        sleep(1);
        printf("parent, *p = %s\n", p);
        wait(NULL);

        int ret = munmap(p, MY_MMAP_SIZE);                 //释放映射区
        if (ret == -1) {
            perror("munmap error");
            exit(1);
        }
    }

    return 0;
}

// 匿名映射方式，不要创建临时文件temp
// MAP_ANONYMOUS linux下才有此宏，类unix系统没有
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <string.h>

#define MY_MMAP_SIZE 20

int main(void)
{
    char *p = NULL;
    pid_t pid;

    p = (char *)mmap(NULL, MY_MMAP_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if(p == MAP_FAILED) { // 注意，不是 p == NULL
        perror("mmap error");
    exit(1);
    }

    pid = fork();                               //创建子进程
    if(pid == 0){
       char *data = "child hello!\n";
        strncpy(p, data, strlen(data) + 1);
       // *p = 1234;
        printf("son, *p = %s\n", p);
    } else {
        sleep(1);
        printf("parent, *p = %s\n", p);
        wait(NULL);

        int ret = munmap(p, MY_MMAP_SIZE);                 //释放映射区
        if (ret == -1) {
            perror("munmap error");
            exit(1);
        }
    }

    return 0;
}

// 类unix系统的匿名映射方法，Linux也可以使用
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <string.h>

#define MY_MMAP_SIZE 20
#define MY_MMAP_FILE "/dev/zero"

int main(void)
{
    char *p = NULL;
    pid_t pid;

    int fd;
    fd = open(MY_MMAP_FILE, O_RDWR);
    if(fd < 0){
        perror("open error");
        exit(1);
    }

    p = (char *)mmap(NULL, MY_MMAP_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if(p == MAP_FAILED) { // 注意，不是 p == NULL
        perror("mmap error");
    exit(1);
    }
    close(fd);                   //映射区建立完毕,即可关闭文件

    pid = fork();                               //创建子进程
    if(pid == 0){
       char *data = "child hello!\n";
        strncpy(p, data, strlen(data) + 1);
       // *p = 1234;
        printf("son, *p = %s\n", p);
    } else {
        sleep(1);
        printf("parent, *p = %s\n", p);
        wait(NULL);

        int ret = munmap(p, MY_MMAP_SIZE);                 //释放映射区
        if (ret == -1) {
            perror("munmap error");
            exit(1);
        }
    }

    return 0;
}

/dev/zero：在类UNIX 操作系统中, /dev/zero 是一个伪文件。
- 产生连续不断的null的流（二进制的零流，而不是ASCII型的）。
- 写入它的输出会丢失不见。
- 主要的用处是用来创建一个指定长度用于初始化的空文件，像临时交换文件。
- 为特定的目的而用零去填充一个指定大小的文件，如挂载一个文件系统到环回设备（loopback device）或"安全地" 删除一个文件。
/dev/null：在类Unix系统中，/dev/null，或称空设备，是一个特殊的设备文件，它丢弃一切写入其中的数据（但报告写入操作成功），读取它则会立即得到一个EOF。
- 被称为位桶(bit bucket)或者黑洞(black hole)。
- 通常被用于丢弃不需要的输出流，或作为用于输入流的空文件。这些操作通常由重定向完成。
- 等价于一个只写文件，并且所有写入它的内容都会永远丢失，而尝试从它那儿读取内容则什么也读不到。
- cat $filename >/dev/null 则不会得到任何信息，因为我们将本来该通过标准输出显示的文件信息重定向到了 /dev/null 中。

// mmap_wr.c
#include<stdio.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/mman.h>


struct STU{
    int id;
    char name[20];
    char sex;
};


void sys_err(char *str)
{
    perror(str);
    exit(1);
}

int main(int argc,char *argv[])
{
    int fd;
    struct STU student = {10, "xiaoming", 'm'};
    struct STU *mm;


    if(argc < 2){
        printf("./a.out file_shared\n");
        exit(-1);
    }


    fd = open(argv[1],O_RDWR | O_CREAT, 0664);
    ftruncate(fd,sizeof(student));


    mm = mmap(NULL, sizeof(student), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (mm == MAP_FAILED)
        sys_err("mmap error");


    close(fd);


    while (1) {
        memcpy(mm, &student, sizeof(student));
        student.id++;
        sleep(1);
    }


    munmap(mm, sizeof(student));
    return 0;
}

// mmap_rd.c
#include<stdio.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
#include<stdlib.h>
#include<sys/mman.h>


struct STU{
    int id;
    char name[20];
    char sex;
};


void sys_err(char *str)
{
    perror(str);
    exit(1);
}


int main(int argc,char *argv[])
{
    int fd;
    struct STU student;
    struct STU *mm;


    if(argc < 2){
        printf("./a.out file_shared\n");
        exit(-1);
    }


    fd = open(argv[1],O_RDONLY);
    if (fd == -1)
    sys_err("open error");

    mm = mmap(NULL,sizeof(student),PROT_READ,MAP_SHARED,fd,0);
    if (mm == MAP_FAILED)
        sys_err("mmap error");


    close(fd);


    while (1) {
        printf("id=%d\tname=%s\t%c\n", mm->id, mm->name, mm->sex);
        sleep(2);
    }
    munmap(mm, sizeof(student));
    return 0;


}

3、套接字（socket）

3.1基本概念

socket套接字本身是为网络通信而设计的，但后来在socket的框架上发展出一种IPC机制，就是Unix Domain Socket。使用Unix Domain Socket的过程跟网络socket十分相似，也要先调用socket()创建一个socket文件描述符，address_family指定为AF_UNIX，type可以选择SOCK_DGRAM或者SOCK_STREAM，protocol参数仍然指定为0即可。

Unix Domain Socket与网络socket编程的区别。

Unix Domain Socket：。

地址格式结构体为sockaddr_un，un表示Unix。

地址是一个socket类型的文件在文件系统中的路径，这个socket文件由bind()调用创建，如果调用bind()时该文件已存在，则bind()错误返回。

struct sockaddr_un {
   __kernel_sa_family sun_family;   /* AF_UNIX */  地址结构类型
   char sun_path[UNIX_PATH_MAX];	/* pathname */ socket文件名（含路径）
};

将Unix Domain socket绑定到一个地址。

size = offsetof(struct sockaddr_un, sunpath) + strlen(un.sun_path);
#define offsetof(type, member) ((int)&((type *)0)->MEMBER)

网络socket编程：

地址格式结构体为sockaddr_in，in表示Internet。

地址是IP地址加上端口号。

struct sockaddr_in {
    __kernel_sa_family_t sin_family; /* Address family */  地址结构类型
    __be16 sin_port;                 /* Port number */     端口号
    struct in_addr sin_addr;         /* Internet address */ip地址
};

3.2例子

// socket_server.c
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <sys/un.h>
#include <stdlib.h>
#include "wrap.h"
#define SERVER_ADDR "server.socket"
#define SERVER_CONNECT_MAX 20

#define rdbuf_size 4096

int main(void)
{
  int lfd, cfd, len, size;
  struct sockaddr_un serveraddr, clientaddr;
  char rdbuf[rdbuf_size] = {0};

  lfd = Socket(AF_UNIX, SOCK_STREAM, 0);

  bzero(&serveraddr, sizeof(serveraddr));
  serveraddr.sun_family = AF_UNIX;
  strncpy(serveraddr.sun_path, SERVER_ADDR, sizeof(SERVER_ADDR));

  len = offsetof(struct sockaddr_un, sun_path) + strlen(serveraddr.sun_path); // serveraddr total len
  
  unlink(SERVER_ADDR);    // 确保bind之前 server.socket 文件不存在，bind() 会创建该文件
  Bind(lfd, (struct sockaddr *)&serveraddr, len); // 参3不能是 sizeof(serveraddr)

  Listen(lfd, SERVER_CONNECT_MAX);

  printf("Accept...\n");

  while(1)
  {
    len = sizeof(clientaddr); // 好像不用这句也行
    cfd = Accept(lfd, (struct sockaddr *)&clientaddr, (socklen_t *)&len);

    len -= offsetof(struct sockaddr_un, sun_path); // 等到文件名的长度
    clientaddr.sun_path[len] = '\0'; // 确保打印时没有乱码

    printf("client bind filename %s \n", clientaddr.sun_path);

    while((size = read(cfd, rdbuf, rdbuf_size)) > 0)
    {
      for(int i = 0; i < size; i++)
              rdbuf[i] = toupper(rdbuf[i]);
      int tmp = size;
      do {
        int tmp2 = write(cfd, rdbuf, tmp);
        if(tmp2 == -1)
        {
                perror("write error:");
                break;
        }
        tmp -= tmp2; 
      } while(tmp > 0);
    }
    close(cfd);
  }
  close(lfd);

  return 0;
  
}

// socket_client.c
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <sys/un.h>
#include "wrap.h"

#define SERVER_ADDR "server.socket"
#define CLIENT_ADDR "client.socket"
#define FGETS_BUF_SIZE 4096


int main(void)
{
  int cfd, len;
  struct sockaddr_un serveraddr, clientaddr;
  char buf[FGETS_BUF_SIZE] = {0};

  cfd = Socket(AF_UNIX, SOCK_STREAM, 0);

  bzero(&clientaddr, sizeof(clientaddr));
  clientaddr.sun_family = AF_UNIX;
  strncpy(clientaddr.sun_path, CLIENT_ADDR, sizeof(CLIENT_ADDR));

  len = offsetof(struct sockaddr_un, sun_path) + strlen(clientaddr.sun_path); // 计算客户端地质结构有效长度

  unlink(CLIENT_ADDR);
  Bind(cfd, (struct sockaddr *)&clientaddr, len); // 客户端也需要bind，不能依赖自动绑定

  bzero(&serveraddr, sizeof(serveraddr));  // 构造server地址
  serveraddr.sun_family = AF_UNIX;
  strncpy(serveraddr.sun_path, SERVER_ADDR, sizeof(SERVER_ADDR));

  len = offsetof(struct sockaddr_un, sun_path) + strlen(serveraddr.sun_path); //计算服务器地址结构有效长度

  Connect(cfd, (struct sockaddr *)&serveraddr, len);

  while(fgets(buf, sizeof(buf), stdin) != NULL)
  {
    write(cfd, buf, strlen(buf));
    len = read(cfd, buf, sizeof(buf));
    write(STDOUT_FILENO, buf, len);
  
  }
  close(cfd);
        
}

// wrap.c 这里是socket的包裹函数
#include <stdio.h>
#include <wrap.h>
void err_sys(const char* x) 
{ 
    perror(x); 
    exit(1); 
}

int Socket(int domain, int type, int protocol)
{
  int n;
  if ((n = socket(domain, type, protocol)) < 0)
    err_sys("socket error");
  return (n);
}

int Bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
  int n;
  if ((n = bind(sockfd, addr, addrlen)) < 0)
    err_sys("bind error");
  return (n);

}

int Listen(int sockfd, int backlog)
{
  int n;
  if ((n = listen(sockfd, backlog)) < 0)
    err_sys("listen error");
  return (n);
  
}

int Accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)
{
  int n;
  if ((n = accept(sockfd, addr, addrlen)) < 0)
    err_sys("accept error");
  return (n);
  
}

int Connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
  int n;
  if ((n = connect(sockfd, addr, addrlen)) < 0)
    err_sys("connect error");
  return (n);
  
}

// wrap.h
#ifndef __WRAP_H
#define __WRAP_H

#include <stdlib.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>

#define offsetof(type, member) ((int)&((type *)0)->member)

int Socket(int domain, int type, int protocol);
int Bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
int Listen(int sockfd, int backlog);
int Accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
int Connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

#endif

# 这个makefile写不是很好，有待整改
all : socket_client socket_server
.PHONY : all

#src = $(wildcard ./*.c) # wildcard函数：显示指定路径下指定文件类型的所有文件
#obj = $(patsubst ./%.c, ./%.o, $(src)) # patsubst函数：.c 替换成 .o
CLIENT_OBJS = socket_client.o wrap.o
SERVER_OBJS = socket_server.o wrap.o

# LIBS := -lpthread
CFLAGS = -I. -g -Wall
CC = gcc
CXX = g++

socket_client : $(CLIENT_OBJS)
  $(CC) -o socket_client $(CLIENT_OBJS) $(CFLAGS) $(LIBS)

socket_server : $(SERVER_OBJS)
  $(CC) -o socket_server $(SERVER_OBJS) $(CFLAGS) $(LIBS)

# $@  表示目标文件
# $<  表示第一个依赖文件
%.o : %.c
  $(CC) -c $(CFLAGS) $< -o $@


# -  即使出错也继续执行后面
.PHONY : clean  # .PHONY 伪目标，有了这句，不管怎样都执行clean
clean :
  -$(RM) socket_server socket_client  $(CLIENT_OBJS) $(SERVER_OBJS)

薛定谔的猫的┗|｀O′|┛ 嗷~~

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
进程间通信IPC

IPCIPC（Inter-Process Communication，进程间通信）。进程间通信是指两个进程的数据之间产生交互。1、管道1.1基本概念管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。本质是一个伪文件（实为内核缓冲区）。有两个文件描述符，一个表示读端(fd[1])，一个表示写端(fd[0])。规定数据从管道的写端流入，从读端流出。双向半双工。原理：管道实为内核使用环形队列机制，借助内核缓冲区（4k）实现。缺点：
复制链接

扫一扫

专栏目录