文章目录
1、管道1.1、匿名管道1.2、有名管道2、信号3、共享内存3.1、共享内存接口3.1.1、生成 key 值3.1.2、创建共享内存3.1.3、创建共享内存映射3.1.4、解除共享内存映射3.1.5、修改共享内存属性3.2、例：共享内存4、信号量4.1、信号量的接口4.1.1、创建信号量4.1.2、控制信号量4.1.3、信号量的操作4.2、例：生产者与消费者问题5、消息队列5.1、消息队列接口5.1.1、创建消息队列5.1.2、发送消息5.1.3、读取消息5.1.4、控制队列5.2、例：消息队列6、socket6.1、socket 网络模型6.1.1、tcp 流程6.1.2、udp 流程6.2、socket APIsocketbindlistenacceptconnectcloserecvsendrecvfromsendto每个进程的用户地址空间都是独立的，一般而言是不能互相访问的，但内核空间是每个进程都共享的，所以进程之间要通信必须通过内核。
进程间通信 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.pipemkfifo 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 或 0int 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 数组来 SETALLunsigned short arr[2] = {0, 5}; // 初始：商品数量 0，货架数量 5semctl(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：指定该地址的长度*/
