每个进程的用户地址空间都是独立的，一般而言是不能互相访问的，但内核空间是每个进程都共享的，所以进程之间要通信必须通过内核。

进程间通信 IPC（ inter-process communication）分为：

• 同一主机进程间通信

  • Unix 通信方式：匿名管道、有名管道、信号
  • system V 通信方式：消息队列、共享内存、信号量

• 不同主机进程间通信：Socket

# system V
# 查看 ipc 信息
ipcs [options]
-l '查看各个 IPC 的限制 

# 移除 ipc 资源
ipcrm [options]
-m shmid '根据 shmid 删除
-M shmid '根据键值删除

1、管道

管道本质就是内核缓冲，其主要特点为：

• 管道的通信方式是半双工的。即只能从管道的写端将数据写入到内核管道缓冲区，再从管道的读端将该数据读出。若要实现全双工通信，必须创建两条管道。
• 管道是基于字节流来通信的，先进先出，数据没有边界。多次写管道，数据粘在一起。
• 管道关闭读端，写管道，收到 SIGPIPE 信号；管道关闭写端，读管道，返回 0。

管道根据其存在的方式分为

• 匿名管道：只存在于内存，只能在有亲缘关系之间的进程进行通信，生命周期随进程的结束而结束
• 有名管道：存在于文件系统，可以在非亲缘关系的进程间通信，是一种管道类型的设备文件，生命周期随内核。

1.1、匿名管道

匿名管道 pipe 只能在有亲缘关系（父子、兄弟）之间的进程进行通信。

创建匿名管道

/*
返回值：成功返回 0，失败返回 -1

参数
- pepefd: 整型数组，保存管道的两端，fd[1]是管道的写端 fd，fd[0]是管道的读端 fd
*/
int pipe(int pepefd[2]);

单个进程的管道没有任何价值。通过 fork 创建子进程，内核管道缓冲区采用 dup 机制进行拷贝的，而用户态数据则是拷贝了一份副本，这样两个进程可以通过各自的 fd 和读取同一个管道文件实现跨进程通信。

// dup 机制：复制文件描述符
// 选择最小可用的 fd 指向 oldfd 所指向的文件对象
int dup(int oldfd);
// 自定义 newfd 指向 oldfd 指向的文件对象。若 newfd 已经被使用，则先关闭，后使用
int dup2(int oldfd, int newfd);

同时为避免父子进程同时写入读取管道造成混乱，通常的做法是：父子进程只保留一端通信（相反）。例如：父进程保留写端，关闭读端；子进程保留读端，关闭写端。

此外，对于管道命令 A | B，将前一个命令A的输出，作为后一个命令B的输入。在 shell 里面执行 A | B命令的时候，A 进程和 B 进程都是 shell 创建出来的子进程，A 和 B 之间不存在父子关系，它俩的父进程都是 shell。

测试1：管道关闭读端，写管道，收到 SIGPIPE 信号，进程退出。使用echo $?查看进程的退出码是 141

// 管道关闭读端，写管道
#include <func.h>

int main(int argc, char **argv) {
    int fds[2];
    int ret = 0;
    ret = pipe(fds);
    ERROR_CHECK(ret, -1, "pipe");

    if(fork()){
        // 父进程关闭读端，写管道
        close(fds[0]);
        // 让出cpu，等待子进程关闭读端
        sleep(1);
        ret = write(fds[1], "hello", 5);
        printf("ret = %d\n", ret);
        ERROR_CHECK(ret, -1, "write");

        wait(NULL);
    }
    else {
        close(fds[0]);
    }
    return 0;
}

测试2：管道关闭写端，读管道，那么 read 会变成非阻塞的，返回 0

// 管道关闭写端，读管道
#include <func.h>

int main(int argc, char **argv) {
    int fds[2];
    int ret = 0;
    ret = pipe(fds);
    ERROR_CHECK(ret, -1, "pipe");

    if(fork()){
        close(fds[1]);
        wait(NULL);
    }
    else {  
        close(fds[1]);
        char buf[64] = {0};
        ret = read(fds[0], buf, sizeof(buf));
        printf("buf = %s, ret  =%d \n", buf, ret);
    }
    return 0;
}

1.2、有名管道

有名管道 FIFO 可以在非亲缘关系的进程间通信，是一种类型为管道的设备文件，不会随着进程结束而消失。注意：管道文件不能用于存储数据，不能用命令打开管道。

创建和删除管道文件

/*
@ brief: 创建有名管道
@ pathname: 创建的命令管道
@ mode: 权限
@ return: 成功返回 0，失败返回 -1
*/
int mkfifo(const char *pathname, mode_t mode)

    
/*
@ brief: 删除文件
@ path: 文件路径
@ return: 成功返回 0，失败返回 -1
*/
int unlink(const char *path);

例：有名管道实现的简易即时通信

创建两个管道文件

mkfifo 1.pipe
mkfifo 2.pipe

代码实现

// ./chat1 1.pipe 2.pipe
#include <func.h>
int main(int argc, char *argv[]) { 
    int fdr = open(argv[1], O_RDONLY);
    int fdw = open(argv[2], O_WRONLY);
    puts("chat1");
    char buf[4096] = {0};
    while(1){
        // 等待键盘输入
        memset(buf ,0, sizeof(buf));
        read(STDIN_FILENO, buf, sizeof(buf));
        // 发送消息到管道
        write(fdw, buf, strlen(buf));
        memset(buf, 0, sizeof(buf));
        // 从管道读取消息
        read(fdr, buf, sizeof(buf));
        puts(buf);
    }
    return 0;
}


// ./chat2 1.pipe 2.pipe
#include <func.h>
int main(int argc, char *argv[]) {
    int fdw = open(argv[1], O_WRONLY);
    int fdr = open(argv[2], O_RDONLY);
    puts("chat2");
    char buf[4096] = {0};
    while(1){
        // 从管道读取消息
        memset(buf,0,sizeof(buf));
        read(fdr,buf,sizeof(buf));
        puts(buf);
        // 等待键盘输入
        memset(buf,0,sizeof(buf));
        read(STDIN_FILENO,buf,sizeof(buf));
        // 发送消息到管道
        write(fdw,buf,strlen(buf));
    }
    return 0;
}

2、信号

信号是进程间通信机制中唯一的异步通信机制。内核与进程在任意时刻交互。

信号的处理方式有

• 默认处理
• 忽略信号
• 捕捉信号，并自定义处理

关于信号的更多内容，见我的博客 linux_信号

3、共享内存

每个进程都有自己独立的虚拟内存空间，不同进程的虚拟内存映射到不同的物理内存中。不同进程间的通信，都要发生用户态与内核态之间的数据拷贝。A 进程将用户态数据拷贝到内核缓冲区，B 进程从内核缓冲区将数据拷贝到用户态。

共享内存的机制，就是拿出一块虚拟地址空间来，映射到相同的物理内存中。这样 A 进程和 B 进程不需要互相拷贝数据，直接就可以看到共享的数据，提高了进程间通信的效率。

注意：共享内存一旦创建后，就会一直存在，不会随进程的结束而消失，直到使用命令删除，或者重启系统。后续的消息队列

3.1、共享内存接口

system V 版本的共享内存创建方法

• 生成 key 值：ftok
• 创建共享内存：shmget
• 将共享内存映射到本进程的地址空间：shmat

3.1.1、生成 key 值

内核使用一个非负整数 key 来区分不同的共享内存区域，不同的进程可以使用同一个 key 值来区分不同的共享内存区域。key 可以手动指定，也可以使用 ftok 接口生成。ftok 是用文件的索引节点号和用户指定的值生成 key 值。

/*
返回值: 成功返回一个key（8位的整型值），失败返回-1。
参数
- pathname: 路径所指向的文件（文件夹）必须真实存在且可访问的文件
- proj_id: 用户指定的值
*/
key_t ftok(const char *pathname, int proj_id);

3.1.2、创建共享内存

/*
返回值：成功返回共享内存id， 失败返回-1
参数
- key：key 值，可以使用 ftok 函数生成，也可以自己指定。
- size：创建共享内存的大小
- shmflg：权限，IPC_CREAT|0666；
*/  
int shmget(key_t key, size_t size, int shmflg)

私有共享内存：当 key 值为全 0 的时候，是私有的共享内存。只能在有亲缘关系间的进程之间使用。私有方式的共享内存不受 key 约束，并且每次执行都会生成新的一块共享内存

// shmget 生成共享内存时，key 指定 IPC_PRIVATE 或 0
int shmid = shmget(IPC_PRIVATE, 1024, IPC_CREAT|0666);

3.1.3、创建共享内存映射

/*
shmat：at-attach
返回值：成功返回指向该共享内存的指针，失败是返回（void*)-1,

参数
- shmid：共享内存的id 
- shmaddr：填NULL，表示让内核决定一个合适的位置
- shmflg：权限，暂时无用，填0；
*/
void *shmat(int shmid, const void *shmaddr, int shmflg);

3.1.4、解除共享内存映射

/*
shmdt：dt-detach
返回值：成功返回0，失败返回(void *)-1
参数
- shmaddr: shmat的返回指针
*/
int shmdt(const void *shmaddr)

3.1.5、修改共享内存属性

shmctl: ctl-control

/*
返回值：成功返回0，失败返回-1

参数
- shmid：共享内存的id 
- cmd：IPC_STAT 获取共享内存的信息; IPC_SET 设置共享内存信息; IPC_RMID 标记删除该共享内存
- buf：是一个结构体，保存共享内存的相关信息
*/
int shmctl(int shmid, int cmd, struct shmid_ds *buf)

**标记删除：**该共享内存正在使用（连接数不为0），该共享内存不会立即被删除，先将其键值置0,。当该共享内存不在被使用的时候，才会真正的删除。

// 获取共享内存的信息
struct shmid_ds stat; 
int ret = shmctl(shmid, IPC_STAT, &stat);

// 修改共享内存段信息
stat.shm_perm.mode = 0666; 
ret = shmctl(shmid, IPC_SET, &stat);

// 删除共享内存
int ret = shmctl(shmid, IPC_RMID, NULL);

3.2、例：共享内存

写进程

#include <func.h>

int main(int argc,char*argv[]) {
    int ret = 0;
    
    // ftok 生成 key 值
    key_t key  = ftok(".", 1);
    ERROR_CHECK(key, -1, "ftok");
    
    // 创建共享内存
    int shmid = shmget(key, 1024, IPC_CREAT|0666);  
    ERROR_CHECK(shmid, -1, "shmget");
    
    // 将共享内存映射到本进程的地址空间
    char *p = (char *)shmat(shmid, NULL, 0);
    ERROR_CHECK(p, (void*)-1, "shmat");
    
    strcpy(p, "How are you");
    
    // 解除映射
    ret = shmdt(p);
    ERROR_CHECK(ret, -1, "shmdt");
    
    return 0;
}

读进程

#include <func.h>

int main(int argc,char*argv[]) {
    int ret = 0;
    
    // ftok 生成 key 值
    key_t key  = ftok(".", 1);
    ERROR_CHECK(key, -1, "ftok");
    
    // 创建共享内存
    int shmid = shmget(key, 1024, IPC_CREAT|0666);  
    ERROR_CHECK(shmid, -1, "shmget");
    
    // 将共享内存映射到本进程的地址空间
    char *p = (char *)shmat(shmid, NULL, 0);
    ERROR_CHECK(p, (void*)-1, "shmat");
    
    puts(p);

    // 解除映射
    ret = shmdt(p);
    ERROR_CHECK(ret, -1, "shmdt");
    
    // 删除映射
    ret = shmctl(shmid, IPC_RMID, NULL);
    ERROR_CHECK(ret, -1, "shmctl");
	
    // ipcs 查看状态，结束后共享内存删除
    while(1);
    
    return 0;
}

4、信号量

信号量一种用于进程间同步的 IPC，不用于缓存数据。

信号量是一个整型计数器，表示有多少个共享资源可以共享使用。控制信号量的方式有两种原子操作

• p 操作：获取资源，信号量数值减 1。若减 1 后，信号量数值等于 0，则阻塞进程。
• v 操作：归还资源，信号量数值加 1。若加 1 后，信号量数值大于 0，唤醒进程。

信号量的分类

• 互斥信号量（二进制信号量）：只有 0 | 1 两种状态的信号量，用于互斥。

• 整型信号量（计数信号量）：具有多个资源的信号量，用于同步。

下文以 system V 版本的信号量为例，进行说明。

4.1、信号量的接口

4.1.1、创建信号量

使用接口 semget 创建信号量集合的时候，如果不是采用私有的方式创建信号量集合，那么多个进程传入同一个key来重复使用 semget 时，必须是不能修改信号量集合的大小的。

/*
返回值：成功返回信号量的 id、失败返回 -1

参数
- key: key 值
- nsems: 信号量的个数，
- semflg: IPC_CREAT|0600;
*/
int semget(key_t key, int nsems, int semflg);

4.1.2、控制信号量

/*
返回值：失败返回 -1

参数
- semid：信号量 id
- semnum：某个信号量在信号量集合中的索引
    union semun{ 
        int val; //val for SETVAL 
        struct semid_ds *buf; //buffer for IPC_STAT,IPC_SET 
        unsigned short *arry; //Array for GETALL,SETALL,0所有元素 
    }

- cmd 
	GETVAL：获取信号量所代表资源的数量，semctl 返回该值 
    SETVAL：设置信号量所代表的资源数量，semctl 成功返回0

    // 创建一个 unsigned short 的数组，数组中的值是各个信号量值的初始值
    GETALL：获取所有信号量的各自所代表的资源数量
    SETALL：设置所有信号量所代表的资源数量
    
    IPC_STAT：获取信号量集合的状态
    IPC_SET：设置信号量集合的状态
    
    IPC_RMID: 删除信号量
*/
int semctl(int semid, int semnum, int cmd, ...)

4.1.3、信号量的操作

/*
返回值：成功返回0， 失败-1

参数
- semid: 信号量id
- sops: 操作信号的结构体，用户自己声明   
    struct sembuf { 
        unsigned short sem_num; // 要操作的信号量编号
        short sem_op;  		   // 信号量的操作
        short sem_flg; 		   // 标志，填0. SEM_UNDO，避免死锁。 
    }; 
- nsops: 结构体的数量
*/
int semop(int semid, struct sembuf *sops, size_t nsops)

4.2、例：生产者与消费者问题

生产者生产商品，消耗货架；消费者消费商品，归还货架。

#include <head.h>

int main(int argc, char **argv) {
    int ret = 0;
    // 创建信号量集合
    int semid = semget(3000, 2, IPC_CREAT|0666);
    ERROR_CHECK(semid, -1, "semget");

    // 创建 unsigned short 数组来 SETALL
    unsigned short arr[2] = {0, 5}; // 初始：商品数量 0，货架数量 5
    semctl(semid, 0, SETALL, arr);  // 0 表示对全部信号量操作
	
    // 信号量的操作函数，数组一次实现两个原子操作
    struct sembuf sop[2];
    memset(sop, 0, sizeof(sop));

    // 父进程：生产者，生产商品，消耗货架
    if(fork()){ 
        sop[0].sem_num = 0;  // 对信号量 0 操作，即商品  
        sop[0].sem_op = 1;   // 生产商品
        sop[0].sem_flg = 0;

        sop[1].sem_num = 1;  // 对信号量 1 操作，即货架
        sop[1].sem_op = -1;  // 消耗货架
        sop[1].sem_flg = 0;
        while(1){
            // 信号量操作
            ret = semop(semid, sop, 2);
           
		   // GETVAL 直接返回信号代表的资源数量
            printf("生产者：商品的数量 = %d, 货架的数量 = %d\n", 
                   semctl(semid, 0, GETVAL), semctl(semid, 1, GETVAL));
            sleep(1);
        }
    }
	// 子进程：消费者，消耗商品，释放货架
    else{ 
        sop[0].sem_num = 0;
        sop[0].sem_op = -1;
        sop[0].sem_flg = 0;
        
        sop[1].sem_num = 1;
        sop[1].sem_op = 1;
        sop[1].sem_flg = 0;

        while(1){
            ret = semop(semid, sop, 2);

            printf("消费者：商品的数量 = %d, 货架的数量 = %d\n", 			   
                   semctl(semid, 0, GETVAL), semctl(semid, 1, GETVAL));
            sleep(2);
        }
    }
    return 0;
}

5、消息队列

消息队列 MQ 是一种多进程间通信的机制。区别于管道的流式结构，消息队列是一个消息链表，先进先出，并且数据之间是有边界的。通信双方约定好的消息体的数据类型，每个消息体都是固定大小的存储块，如果进程从消息队列中读取了消息体，内核将该消息体删除。

消息队列的使用场景

• 异步处理：消息放入队列但不立即处理，快速返回，减少等待，实现并发处理
• 流量控制（削峰）：隔离网关和后端服务，消息队列能够顶住访问压力，后端不会崩溃。
• 系统解耦：独立的扩展和修改队列两边的处理过程
• 缓冲：解决生产和消费消息的处理速度不一致的问题
• 高可用：数据持久化到磁盘，同时提供备份（冗余存储）

这里仅以本地的 system V 版本的消息队列为例说明。

5.1、消息队列接口

5.1.1、创建消息队列

/*
返回值：成功返回消息队列id，失败返回-1

参数
- 参数1；key值
- 参数2：IPC_CREAT|0666 IPC_EXCL
*/
int msgget(key_t key, int msgflg);

5.1.2、发送消息

/*
返回值：成功返回0， 失败返回-1， 

参数
- 参数1：消息队列id
- 参数2：该结构体重新声明，第二个结构体成员改成自己需要使用的大小
    struct msgbuf {
        long mtype;    // 消息类型
        char mtext[1]; // 消息内容
    };
- 参数3：发送数据的长度
- 参数4：标志位，填0；
*/

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg)

5.1.3、读取消息

/*
返回值：成功返回接收的字节数，失败返回-1

参数
- msqid: 消息队列 id   
- msgp: 接收的信息保存在该结构体中，需重新声明
- msgsz: 最多接收的数据量
- msgtyp: 指定接收哪个类型的数据，0表示无差别接收，负数取绝对值
- msgflg: 标志位，填0。IPC_NOWAIT不阻塞，立即响应 
*/
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

5.1.4、控制队列

/*
返回值：失败返回-1

参数
- 参数1：消息队列id   
- 参数2：CMD。IPC_RMID 删除消息队列 ...
*/
int msgctl(int msqid, int cmd, ...);

5.2、例：消息队列

msgsnd.c 发送数据

#include <func.h>

// 重新声明 msgbuf 结构体，字符数组按自己的需要修改
typedef struct Mymsgbuf{
    long mtype;
    char mtext[10];
} msgbuf_t;

int main(int argc,char*argv[]) {
    int ret = 0;
    int msgid = msgget(1000, IPC_CREAT | 0666);
    
    msgbuf_t mbuf;
    memset(&mbuf, 0, sizeof(mbuf));
    mbuf.mtype = atoi(argv[1]);
    strcpy(mbuf.mtext, argv[2]);

    ret = msgsnd(msgid, &mbuf, strlen(mbuf.mtext), 0);
    
    return 0;
}

msgrcv_nowait.c 接收数据

#include <func.h>

typedef struct Mymsgbuf{
    long mtype;
    char mtext[10];
} msgbuf_t;

int main(int argc,char*argv[]) {
    int ret = 0;
    int msgid = msgget(1000, IPC_CREAT | 0666);
    
    msgbuf_t mbuf;
    memset(&mbuf, 0, sizeof(mbuf));

    long type = atoi(argv[1]);

    ret = msgrcv(msgid, &mbuf, sizeof(mbuf.mtext), type, IPC_NOWAIT); 
    puts(mbuf.mtext);

    return 0;
}

msgclose.c 删除消息队列

#include <func.h>

int main(int argc,char*argv[]) {
    int ret = 0;
    int msgid = msgget(1000, IPC_CREAT | 0666);
    
    ret = msgctl(msgid, IPC_RMID, NULL);

    return 0;
}

6、socket

Socket 不仅可用于跨网络与不同的主机进程间通信，还可以用于本地主机进程间通信。

/*
返回值：成功返回套接口描述符，失败返回-1

参数
- domain：通信域，ipv4: AF_INET, ipv6: AF_INET6, 本地: 、AF_LOCAL/AF_UNIX 
- type：服务类型，tcp：SOCK_STREAM 数据流, udp：SOCK_DGRAM 数据报，SOCK_RAW 原始套接字
- pro‐tocol：指定socket使用的协议编号，通常为0
*/
int socket(int domain, int type, int protocal)

6.1、socket 网络模型

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-get3QQQf-1675329714385)(linux_操作系统.assets/socket流程-16505877282072-16505918825033.jpg)]

6.1.1、tcp 流程

服务端

socket - bind - listen - accept while(1) {- recv - send -} - close

客户端

socket - connect - send - recv - close

6.1.2、udp 流程

服务端

服务端必须要先 recvfrom，然后 sendto。udp 非面向连接的，所以最开始不知道对端的 socket，所以先接收对方发来的而数据，并且记录对端的socket

socket - bind while(1) {- recvfrom - sendto -} - close

客户端

socket - sendto - recvfrom - close

6.2、socket API

更多关于 socket 网络编程的相关内容，参考我的博客

• Posix API与网络协议栈
• IO 多路复用

socket

创建套接字。

int socket(int domain, int type, int pro‐tocol);

/*
返回值：成功返回套接口描述符，失败返回-1
参数
- 参数1 domain：通信域，ipv4: AF_INET  ipv6: AF_INET6
- 参数2 type：服务类型，tcp：SOCK_STREAM  udp：SOCK_DGRAM
- 参数3 pro‐tocol：指定socket使用的协议编号，通常为0
*/

bind

绑定本地的 ip 地址和端口号。

/*
返回值：成功返回0，失败返回-1

参数
- sockfd：socket函数的返回值，
- addr：将addr指向的socket地址分配给sockfd，使用前强制转换成sockaddr
- addrlen：该socket地址的长度
*/
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)；

listen

创建监听队列存放待处理的客户的连接。

/*
返回值：成功返回0，失败返回-1并设置errno

参数
- sockfd：被监听的sockfd
- backlog：同时监听的最大连接数，集内核监听的全连接队列的长度。
  内核2.2前: 半连接队列（SYN_RCVD）+ 全连接队列(ESTABLISHED); 
  内核2.2后和 Mac：全连接队列的数量
*/
int listen(int sockfd, int backlog)

accept

从全连接队列里面取出一个节点并为其分配一个 socket。accept 只是从监听队列中取出连接，而不论连接处于何种状态，更不关心任何网络状况的变化。

/*
返回值：成功返回一个新 sockfd 用于与客户端通信，原来的 sockfd 还可以继续监听其他客户端连接请求，失败返回-1。

参数
- sockfd：监听socket，即处于LISTEN状态的socket
- addr：获取被接受连接的远端的socket地址
- addrlen：结构体长度的变量指针
*/
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen)

connect

主动与服务器建立连接

/*
返回值：成功返回0，失败返回-1

参数
- sockfd：socket系统调用返回 1 个 socket
- addr：服务器监听的 socket 地址
- addrlen：这个地址长度的大小
*/
int connect(int sockfd, const struct sockaddr *addr,  socklen_t addrlen)

close

关闭该连接对应的 fd，将 fd 对应的引用计数减1。当引用计数为0，关闭连接。

/*
返回值：成功返回0，失败返回-1

参数 
- fd：待关闭的 socket
*/
int close(int fd) 

shutdown：立即关闭连接

/*
返回值：成功返回0，失败返回-1

参数
- sockfd：被监听的sockfd
- how：SHUT_RD，SHUT_WR，SHUT_RDWR，分别对应关闭读端、写端、双端
*/
int shutdown(int sockfd, int how);

recv

用于 tcp，从对端接收数据，阻塞性函数

• 将内核缓冲区中的数据拷贝到用户缓冲区
• 同时移走内核缓冲区中的数据

/*
返回值：成功返回实际接收到的字节数；返回0，对端连接断开；返回-1，错误并设置errno

参数
- sockfd
- buf：缓冲区的位置
- len：缓冲区的大小
- flags：标志位，0为默认操作
*/
ssize_t recv(int sockfd, void *buf, size_t len, int flags)

send

用于 tcp，向对端发送数据

/*
返回值：成功返回成功发送的字节数，失败返回-1。

参数
- sockfd
- buf：缓冲区的位置
- len：缓冲区的大小
- flags：标志位，0为默认操作
*/
ssize_t send(int sockfd, const void *buf, size_t len, int flags)

注：read | write 和 recv | send 区别

linux所有的设备都可以看成是一个文件，因此可用 read | write 来读写 socket 数据。

• 若 flags = 0，两者无区别。

• 若 flags != 0，可以是下面组合

   MSG_DONTROUTE // 不查找路由表 
   MSG_OOB       // 接受或发送带外数据 
   MSG_PEEK      // 查看数据,并不从系统缓冲区移走数据
   MSG_WAITALL   // 等待任何数据
  

recvfrom

用于udp，从对端接收数据，并且保存对端的ip和端口

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen)
    
/*
返回值：成功返回读到的字节数，失败返回-1

参数：
- 参数1-4：同tcp
- 参数5 src_addr：发送端的socket地址
- 参数6 addrlen：指定该地址的长度
*/

sendto

向指定的 ip 和端口的对端发送数据

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,  const struct sockaddr *dest_addr, socklen_t addrlen)
 
/*
返回值：成功返回成功发送的字节数，失败返回-1
参数
- 参数1-4：同tcp
- 参数5：接收端的socket地址
- 参数6：指定该地址的长度
*/