• Linux系统编程之进程间通信(IPC)

    一.进程间通信概述

    进程间通信（IPC，InterProcess Communication）是指在不同进程之间传播或交换信息。

    IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket、Streams等。其中 Socket和Streams支持不同主机上的两个进程IPC

    二.管道

    1.匿名管道

    （1）特点

    1.半双工，具有固定的写端和读端

    2.只能用与具有亲缘关系的进程之间的通信（父子进程和兄弟进程之间）

    3.可以看成一种特殊的文件，不属于其他任何文件系统，只存在于内存中

    4.管道中的数据读走就没了

    （2）API

    int pipe(int pipefd[2])

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

    fd[0]：读端，为读而打开 

    fd[1]：写端，为写而打开

    关闭管道：关闭读端和写端      

    使用write函数进行写入，使用read函数进行读出，使用close函数关闭

    1. #include <stdio.h>
    2. #include <unistd.h>
    3. #include <string.h>
    4. #include <stdlib.h>
    5. int main()
    6. {
    7. 	int fd[2];
    8.  
    9. 	int pid;
    10.  
    11. 	char buf[128];
    12.  
    13. //	int pipe(int pipefd[2]);
    14.  
    15. 	if(pipe(fd) == -1){
    16. 		printf("creat pipe failed\n");
    17. 	}
    18. 	pid = fork();
    19. 	
    20. 	if(pid<0){
    21. 		printf("creat child failed\n");
    22. 	}
    23. 	else if(pid > 0){
    24. 		sleep(3);
    25. 		printf("this is father\n");
    26.  
    27. 		close(fd[0]);
    28. 		write(fd[1],"hello from father",strlen("hello form father"));
    29. 		wait();
    30. 	}else{
    31. 		printf("this is child\n");
    32. 		close(fd[1]);
    33. 		read(fd[0],buf,128);
    34. 		printf("read from father: %s\n",buf);
    35. 		exit(0);
    36. 	}
    37. 	
    38.  
    39. 	return 0;
    40. }

     2.有名管道

    （1）特点

    1.可以在无关的进程之间交换数据

    2.有路径名，以一种特别设备文件形式存在于文件系统中，可以用一般的文件I/O函数操作

    （2）API

    int mkfifo(const char *pathname, mode_t mode);

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

    write.c

    1. #include <sys/types.h>
    2. #include <sys/stat.h>
    3. #include <stdio.h>
    4. #include<errno.h>
    5. #include <fcntl.h>
    6. #include <string.h>
    7.  
    8. //       int mkfifo(const char *pathname, mode_t mode);
    9. int main()
    10. {
    11. 	int cnt = 0;
    12. 	char *str = "message from fifo";
    13.  
    14.     if( (mkfifo("./file",IPC_CREAT|0600) == -1) && errno!=EEXIST){
    15. 		printf("mkfifo failuer\n");
    16. 		perror("why");
    17. 	}
    18.  
    19. 	int fd = open("./file",O_WRONLY);
    20. 	printf("write open success\n");
    21. 	
    22. 	while(1){
    23. 		
    24. 		write(fd, str, strlen(str));
    25. 		sleep(1);
    26. 		if(cnt == 5){
    27. 			break;	
    28. 		}
    29. 	}
    30. 	close(fd);
    31. 	return 0;
    32. }
    33.  
    34.

    read.c

    1. #include <sys/types.h>
    2. #include <sys/stat.h>
    3. #include <stdio.h>
    4. #include<errno.h>
    5. #include <fcntl.h>
    6.  
    7. //       int mkfifo(const char *pathname, mode_t mode);
    8. int main()
    9. {
    10. 	char buf[30] = {0};
    11. 	int nread = 0;
    12.  
    13.  
    14. 	if( (mkfifo("./file",0600) == -1) && errno!=EEXIST){
    15. 		printf("mkfifo failuer\n");
    16. 		perror("why");
    17. 	}
    18.  
    19. 	int fd = open("./file",O_RDONLY);
    20. 	printf("open success\n");
    21. 	
    22. 	while(1){
    23. 		nread = read(fd,buf,30);
    24. 	
    25. 		printf("read %d byte from fifo,context:%s\n",nread,buf);
    26. 	}
    27. 	close(fd);
    28. 	return 0;
    29. }
    30.  
    31.

    三.消息队列

    1.特点

    1.消息队列是面向记录的，其中的消息具有特定的格式以及特定的优先权

    2.消息队列对立与发送与接收进程，进程终止时，消息队列及其内容并不会被删除

    3.消息队列可以实现消息的随即查询，消息不一定要以先进先出的次序读取，也可以按消息的类型读取

    2.API

    1.创建或打开消息队列

    int msgget(key_t key, int msgflg);
    返回值：成功返回队列ID，失败返回-1

    2.添加消息

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

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

    3.读取消息

     ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
    返回值：成功返回消息数据的长度，失败返回-1

    4.控制消息队列

    int msgctl(int msqid, int cmd, struct msqid_ds *buf);

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

    msgget创建一个新队列：

    1.如果没有与键值key对应的消息队列，并且flag中包含了IPC_CREAT标志位

    2.key参数为IPC_PRIVATE，创建一个私有消息队列

    msgrcv在读取时的type参数

    type含义
    ==0返回消息队列中的第一个消息
    >0返回队列中消息类型为type的第一个消息
    <0返回队列中消息类型值小于或等于type绝对值的消息，如果有多个，则取类型值最小的消息

    msgSend.c

    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/ipc.h>
    4. #include <sys/msg.h>
    5. #include <string.h>
    6. //       int msgget(key_t key, int msgflg);
    7. //        int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
    8.  
    9. //       ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
    10. //                      int msgflg);
    11. struct msgbuf {
    12.                
    13. 	long mtype;       /* message type, must be > 0 */
    14.         char mtext[256];    /* message data */
    15. };
    16.  
    17.  
    18. int main()
    19. {
    20. 	//1.huoqu
    21. 	struct msgbuf sendBuf = {888,"this is message from quen"};	
    22. 	struct msgbuf readBuf;
    23.  
    24. 	memset(&readBuf,0,sizeof(struct msgbuf));
    25. 	key_t key;
    26.         key = ftok(".",'m');
    27.         printf("key=%x\n",key);
    28.  
    29.         int msgId = msgget(key, IPC_CREAT|0777);
    30.  
    31. 	if(msgId == -1 ){
    32. 		printf("get que failuer\n");
    33. 	}
    34. 	
    35. 	msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);
    36. 	printf("send over\n");
    37.  
    38.         msgrcv(msgId, &readBuf,sizeof(readBuf.mtext),988,0);
    39. 	printf("reaturn from get:%s\n",readBuf.mtext);
    40. 	
    41. 	msgctl(msgId,IPC_RMID,NULL);
    42. 	
    43. 	return 0;
    44. }

    msgGet.c

    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/ipc.h>
    4. #include <sys/msg.h>
    5. #include <string.h>
    6. //       int msgget(key_t key, int msgflg);
    7. //        int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);
    8.  
    9. //       ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp,
    10. //                      int msgflg);
    11. struct msgbuf {
    12.                
    13. 	long mtype;       /* message type, must be > 0 */
    14.         char mtext[256];    /* message data */
    15. };
    16.  
    17.  
    18. int main()
    19. {
    20. 	//1.huoqu
    21. 	struct msgbuf readBuf;	
    22.  
    23.  
    24. 	key_t key;
    25. 	key = ftok(".",'m');
    26. 	printf("key=%x\n",key);
    27.  
    28. 	int msgId = msgget(key, IPC_CREAT|0777);
    29. 	if(msgId == -1 ){
    30. 		printf("get que failuer\n");
    31. 	}
    32. 	memset(&readBuf,0,sizeof(struct msgbuf));
    33.  
    34. 	msgrcv(msgId, &readBuf,sizeof(readBuf.mtext),888,0);	
    35. 	printf("read from que:%s\n",readBuf.mtext);
    36.  
    37.         struct msgbuf sendBuf = {988,"thank you for reach"};
    38.         msgsnd(msgId,&sendBuf,strlen(sendBuf.mtext),0);
    39.  
    40. 	msgctl(msgId,IPC_RMID,NULL);
    41.  
    42. 	return 0;
    43. }

    四.共享内存

    1.注意事项

    共享内存大小以M对齐

    2.API

    1.创建或获取一个共享内存

    int shmget(key_t key, size_t size, int shmflg);

    返回值：成功返回共享内存ID，失败返回-1

    2.连接共享内存到当前进程的地址空间

    void *shmat(int shmid, const void *shmaddr, int shmflg);

    返回值：成功返回指向共享内存的指针，失败返回-1

    shmflg = 0即为可读可写

    shmaddr = 0即让内存分配共享空间

    3.断开与共享内存的连接

    int shmdt(const void *shmaddr);

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

    4.控制共享内存的相关信息

    int shmctl(int shmid, int cmd, struct shmid_ds *buf);

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

    ipcs -m：查看系统中有哪些共享内存

    ipcrm -m 共享内存ID ：删除共享内存

    shmw.c

    1. #include <sys/ipc.h>
    2. #include <sys/shm.h>
    3. #include <stdlib.h>
    4. #include <stdio.h>
    5. #include <string.h>
    6.  
    7. //int shmget(key_t key, size_t size, int shmflg);
    8. int main()
    9. {
    10. 	
    11. 	int shmid;
    12. 	char *shmaddr;
    13.  
    14. 	
    15. 	key_t key;
    16. 	key = ftok(".",1);
    17. 	
    18. 	shmid = shmget(key,1024*4,IPC_CREAT|0666);
    19. 	if(shmid == -1){
    20. 		printf("shmget noOk\n");
    21. 		exit(-1);
    22. 	}
    23. 	shmaddr = shmat(shmid,0,0);
    24.  
    25. 	printf("shmat ok\n");
    26. 	strcpy(shmaddr,"chenlichen");
    27.  
    28. 	sleep(5);
    29. 	shmdt(shmaddr);
    30. 	shmctl(shmid, IPC_RMID, 0);
    31.  
    32. 	printf("quit\n");
    33. 	
    34. 	return 0;
    35. }

    shmr.c

    1. #include <sys/ipc.h>
    2. #include <sys/shm.h>
    3. #include <stdlib.h>
    4. #include <stdio.h>
    5. #include <string.h>
    6.  
    7. //int shmget(key_t key, size_t size, int shmflg);
    8. int main()
    9. {
    10. 	
    11. 	int shmid;
    12. 	char *shmaddr;
    13.  
    14. 	
    15. 	key_t key;
    16. 	key = ftok(".",1);
    17. 	
    18. 	shmid = shmget(key,1024*4,0);
    19. 	if(shmid == -1){
    20. 		printf("shmget noOk\n");
    21. 		exit(-1);
    22. 	}
    23. 	shmaddr = shmat(shmid,0,0);
    24.  
    25. 	printf("shmat ok\n");
    26. 	printf("data: %s\n:",shmaddr);
    27.  
    28. 	shmdt(shmaddr);
    29.  
    30. 	printf("quit\n");
    31. 	
    32. 	return 0;
    33. }

    五.信号

    1.概述

    kill -l：查看系统中所有信号

    信号处理：忽略、捕捉或默认动作

    SIGKILL、SIGSTOP不可忽略

    2.API

    1.信号处理函数的注册

    sighandler_t signal(int signum, sighandler_t handler);

    int sigaction(int signum, const struct sigaction *act,struct sigaction *oldact);

    忽略信号：SIG_IGN

    kill -信号id 进程号：给指定进程发送指定信号

     struct sigaction {
                   void     (*sa_handler)(int);
                   void     (*sa_sigaction)(int, siginfo_t *, void *);        //最后一个参数非空为有数据，为空就是没数据
                   sigset_t   sa_mask;        //默认阻塞，处理一个信号
    时不处理其他信号               

                    int        sa_flags;        //SA_SIGINFO：收数据
               };

    2.信号发送函数

    int kill(pid_t pid, int sig);

     int sigqueue(pid_t pid, int sig, const union sigval value);

    union sigval {
                   int   sival_int;
                   void *sival_ptr;
               };
    signalDemo1.c

    1. #include 
    2. #include 
    3.  
    4. //       typedef void (*sighandler_t)(int);
    5.  
    6. //       sighandler_t signal(int signum, sighandler_t handler);
    7.  
    8. void handler(int signum)
    9. {
    10. 	printf("get signum=%d\n",signum);
    11. 	switch(signum){
    12. 		case 2:
    13. 			printf("SIGINT\n");
    14. 			break;
    15. 		case 9:
    16. 			printf("SIGKILL\n");
    17. 			break;
    18. 		case 10:
    19. 			printf("SIGUSR1\n");
    20. 			break;
    21.  
    22. 	}
    23.  
    24.  
    25.  
    26.  
    27. 	printf("never quit\n");
    28. }
    29.  
    30. int main()
    31. {
    32. 	signal(SIGINT,SIG_IGN);
    33. 	signal(SIGKILL,SIG_IGN);
    34. 	signal(SIGUSR1,handler);
    35. 	while(1);
    36. 	return 0;
    37. }
    38.  
    39.

    signalDemo1CON.c

    1. #include 
    2. #include 
    3. #include 
    4.  
    5.  
    6. int main(int argc ,char **argv)
    7. {
    8. 	int signum;
    9. 	int pid;
    10.  
    11. 	char cmd[128]={0};
    12.  
    13. 	signum = atoi(argv[1]);
    14. 	pid = atoi(argv[2]);
    15.  
    16. 	printf("num=%d,pid=%d\n",signum,pid);	
    17.  
    18. //	kill(pid, signum);
    19. 	sprintf(cmd,"kill -%d %d",signum,pid);
    20.  
    21. 	
    22. 	system(cmd);
    23.  
    24. 	printf("send signal ok");	
    25. 	return 0;
    26. }
    27.  
    28.

    NiceSignal.c

    1. #include <signal.h>
    2. #include <stdio.h>
    3.  
    4. //       int sigaction(int signum, const struct sigaction *act,
    5. //                     struct sigaction *oldact);
    6.  
    7. void   handler(int signum , siginfo_t *info, void *context)
    8. {
    9. 	printf("get signum %d\n",signum);
    10. 	
    11. 	if(context != NULL){
    12.  
    13. 		printf("from:%d\n",info->si_pid);
    14. //		printf("get data=%d\n",info->si_int);
    15. //		printf("get data=%d\n",info->si_value.sival_int);
    16. //		printf("get data=%s\n",context);
    17. 		printf("get data=%d\n",*(int *)(info->si_value.sival_ptr));
    18. 	}
    19. }
    20.  
    21. int main()
    22. {
    23. 	struct sigaction act;
    24. 	printf("pid = %d\n",getpid());
    25.  
    26. 	act.sa_sigaction = handler;
    27. 	act.sa_flags = SA_SIGINFO; //be able to get message
    28.  
    29.  
    30. 	sigaction(SIGUSR1,&act,NULL);
    31. 	while(1);
    32. 	return 0;
    33.  
    34. }
    35.

    sendSignal.c

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. //      int sigqueue(pid_t pid, int sig, const union sigval value)
    8.  
    9. int main(int argc, char **argv)
    10. {
    11.         int signum;
    12.         int pid;
    13.         union sigval value;
    14.  
    15.         signum = atoi(argv[1]);
    16.         pid = atoi(argv[2]);
    17.         value.sival_int = 100;
    18.  
    19.         sigqueue(pid,signum,value);
    20.  
    21.         printf("%d,done\n",getpid());
    22.  
    23.         return 0;
    24. }

    六.信号量

    信号量是一个计数器，用于实现进程间的互斥与同步，而不是用于存储进程间通信数据

    1.特点

    1.信号量用于进程间同步，若要在进程间传递数据需结合共享内存

    2.信号量基于操作系统的PV操作，程序对信号量的操作都是原子操作

    3.每次对信号量的PV操作不仅限于对信号量值加1或减1，而且可以加减任意正整数

    4.支持信号量组

    2.API

    1.创建或获取一个信号量组

    int semget(key_t key, int nsems, int semflg);

    返回值：返回成功返回信号量集ID，失败返回-1

    2.对信号量组进行操作

    int semop(int semid, struct sembuf *sops, size_t nsops);

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

    3.控制信号量的相关信息

    int semctl(int semid, int semnum, int cmd, ...);

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

    P操作：取信号量

    V操作：存信号量

    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/ipc.h>
    4. #include <sys/sem.h>
    5. #include <unistd.h>
    6.  
    7. //      int semget(key_t key, int nsems, int semflg);
    8. //      int semctl(int semid, int semnum, int cmd, ...);
    9. //      int semop(int semid, struct sembuf *sops, size_t nsops);
    10.  
    11. union semun {
    12.        int              val;    /* Value for SETVAL */
    13.        struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    14.        unsigned short  *array;  /* Array for GETALL, SETALL */
    15.        struct seminfo  *__buf;  /* Buffer for IPC_INFO
    16.                                    (Linux-specific) */
    17. };
    18.  
    19. void pHandler(int semid)
    20. {
    21.         struct sembuf sop;
    22.  
    23.         sop.sem_num = 0;
    24.         sop.sem_op = -1;
    25.         sop.sem_flg = SEM_UNDO;
    26.  
    27.         semop(semid,&sop,1);
    28.         printf("get key\n");
    29. }
    30.  
    31. void vHandler(int semid)
    32. {
    33.         struct sembuf sop;
    34.  
    35.         sop.sem_num = 0;
    36.         sop.sem_op = 1;
    37.         sop.sem_flg = SEM_UNDO;
    38.  
    39.         semop(semid,&sop,1);
    40.         printf("put back key\n");
    41. }
    42.  
    43. int main()
    44. {
    45.         key_t key;
    46.         int semid;
    47.         union semun initsem;
    48.         int pid;
    49.  
    50.         key = ftok(".",2);
    51.         semid = semget(key,1,IPC_CREAT|0666);
    52.  
    53.         initsem.val = 0;
    54.  
    55.         semctl(semid,0,SETVAL,initsem);
    56.  
    57.         pid = fork();
    58.         if(pid > 0){
    59.                 pHandler(semid);
    60.                 printf("this is father\n");
    61.                 vHandler(semid);
    62.                 semctl(semid,0,IPC_RMID);
    63.         }else if(pid == 0){
    64.                 printf("this is child\n");
    65.                 vHandler(semid);
    66.         }else{
    67.                 printf("fork falied\n");
    68.         }
    69.  
    70.         return 0;
    71. }

    3.信号量与共享内存结合

    send.c

    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/ipc.h>
    4. #include <sys/sem.h>
    5. #include <sys/shm.h>
    6. #include <unistd.h>
    7.  
    8. //       int semget(key_t key, int nsems, int semflg);
    9. union semun {
    10.        int              val;    /* Value for SETVAL */
    11.        struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    12.        unsigned short  *array;  /* Array for GETALL, SETALL */
    13.        struct seminfo  *__buf;  /* Buffer for IPC_INFO
    14.                                    (Linux-specific) */
    15. };
    16.  
    17. void pHandler(int semid)
    18. {
    19.         struct sembuf sop;
    20.  
    21.         sop.sem_num = 0;
    22.         sop.sem_op = -1;
    23.         sop.sem_flg = SEM_UNDO;
    24.  
    25.         semop(semid,&sop,1);
    26.         printf("get key\n");
    27. }
    28.  
    29. void vHandler(int semid)
    30. {
    31.         struct sembuf sop;
    32.  
    33.         sop.sem_num = 0;
    34.         sop.sem_op = 1;
    35.         sop.sem_flg = SEM_UNDO;
    36.  
    37.         semop(semid,&sop,1);
    38.         printf("put back key\n");
    39. }
    40.  
    41. int main()
    42. {
    43.         key_t key;
    44.         int semid;
    45.         union semun initsem;
    46.         int shmid;
    47.         char *shm;
    48.  
    49.         key = ftok(".",3);
    50.         semid = semget(key,1,IPC_CREAT|0666);
    51.         printf("semid = %d\n",semid);
    52.         initsem.val = 0;
    53.         semctl(semid,0,SETVAL,initsem);
    54.  
    55.         shmid = shmget(key,1024*4,IPC_CREAT|0666);
    56.         shm = shmat(shmid,0,0);
    57.  
    58.         sprintf(shm,"ccy handsome");
    59.         vHandler(semid);
    60.  
    61.         sleep(5);
    62.  
    63.         pHandler(semid);
    64.         printf("context:%s\n",shm);
    65.         vHandler(semid);
    66.  
    67.         shmdt(shm);
    68.         shmctl(shmid,IPC_RMID,NULL);
    69.  
    70.         return 0;
    71. }

    read.c

    1. #include <stdio.h>
    2. #include <sys/types.h>
    3. #include <sys/ipc.h>
    4. #include <sys/sem.h>
    5. #include <sys/shm.h>
    6. #include <unistd.h>
    7.  
    8. //       int semget(key_t key, int nsems, int semflg);
    9. union semun {
    10.        int              val;    /* Value for SETVAL */
    11.        struct semid_ds *buf;    /* Buffer for IPC_STAT, IPC_SET */
    12.        unsigned short  *array;  /* Array for GETALL, SETALL */
    13.        struct seminfo  *__buf;  /* Buffer for IPC_INFO
    14.                                    (Linux-specific) */
    15. };
    16.  
    17. void pHandler(int semid)
    18. {
    19.         struct sembuf sop;
    20.  
    21.         sop.sem_num = 0;
    22.         sop.sem_op = -1;
    23.         sop.sem_flg = SEM_UNDO;
    24.  
    25.         semop(semid,&sop,1);
    26.         printf("get key\n");
    27. }
    28.  
    29. void vHandler(int semid)
    30. {
    31.         struct sembuf sop;
    32.  
    33.         sop.sem_num = 0;
    34.         sop.sem_op = 1;
    35.         sop.sem_flg = SEM_UNDO;
    36.  
    37.         semop(semid,&sop,1);
    38.         printf("put back key\n");
    39. }
    40.  
    41. int main()
    42. {
    43.         key_t key;
    44.         int semid;
    45.         union semun initsem;
    46.         int shmid;
    47.         char *shm;
    48.  
    49.         key = ftok(".",3);
    50.         semid = semget(key,1,IPC_CREAT|0666);
    51.         printf("semid = %d\n",semid);
    52.         initsem.val = 0;
    53.         semctl(semid,0,SETVAL,initsem);
    54.  
    55.         shmid = shmget(key,1024*4,IPC_CREAT|0666);
    56.         shm = shmat(shmid,0,0);
    57.         pHandler(semid);
    58.         printf("context:%s\n",shm);
    59.         vHandler(semid);
    60.  
    61.         pHandler(semid);
    62.         sprintf(shm,"thank you for using");
    63.         vHandler(semid);
    64.  
    65.         shmdt(shm);
    66.         shmctl(shmid,IPC_RMID,NULL);
    67.  
    68.         return 0;
    69. }

  • 相关阅读:
    MySql数据库入门的基本操作
    弹性资源组件elastic-resource设计(二)-集群
    ChatGPT 和 Midjourney 将改变我们的生活,日常工作流程将完全改变并与这些新型工具集成
    HS6621Cx 一款低功耗蓝牙SoC芯片 应用于键盘、鼠标和遥控器消费类产品
    Facebook：数字时代的文化交流平台
    Object构造函数的方法
    Python：实现日历到excel文档
    谈谈什么是数据质量管理
    管理会计学复习题集
    自动驾驶 知识点 Review 2D 感知算法 二（单阶段法 Yolo系列，SSD系列，RetinaNet）
  • 原文地址：https://blog.csdn.net/2303_77402228/article/details/139349958