进程间通信

最新推荐文章于 2022-03-07 20:34:49 发布
最新推荐文章于 2022-03-07 20:34:49 发布
阅读量131 收藏
点赞数 1
分类专栏： 面试复习 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wzf_Cql/article/details/120686575
版权

进程间通信：俩个进程间进行数据的交互，主要有以下类型
无名管道
有名管道
信号
共享内存
消息队列
信号量
套接字
这七种通讯方式：

一、无名管道 pipe

#include <unistd.h>
int pipe(int pipefd[2]);
pipe的参数是一个数组，数组里面有放的是两个pidfd进程描述符。
pidfd[0]:读端
pidfd[1]:写端
write(pidfd[1] , buf,sizeof(buf));
就可以通过写端，把数据写到无名管道里面。
read(pid[0],buf,sizeof(buf));
就可以把无名管道的数据读道buf里面
读写的进程必须是亲缘进程

无名管道是在内核中开辟的一段空间，（内核本来就有这个空间，不是我们调用pipe才开辟的）
无名管道限制较大：只能用于亲缘进程间进行通信。即父子进程和兄弟进程间进行通信。
使用无名管道pipe就会在进程开辟一个读端和一个写端。且无名管道只能十单工通信的，就是，你自己定义好两个进程间谁是读端，谁是写端。
原本就存在内核里面的无名管道pipe有固定大小，这设置内核的时候就已经固定好了，linux下为64k，最多能存放65535个字节。
在这里插入图片描述
二、有名管道：FIFO

#include <sys/types.h>
#include <sys/state.h>
int mkfifi(const char *filename ,mode_t mode); 创建有名管道filename 为fifo的管道 mode为管道权限，一般为可读可写0666

然后你再通标准io去读写管道
读进程先open const char *filename这个文件且为只读模式。
然后read();到buf。
写进程：open const char *filename这个文件且为只写模式。
然后把buf wrinte到buf.

既然无名管道有这么多的限制，那么为了解决进程间通信的这些问题，引入了有名管道。
有名管道有以下特点：
1）适用于任何进程间进行通信
2）它没有大小的限制
以上特性的原因是因为有名管道的通信机制。他是通过把数据写在一个文件中，然后另一个进程再去读这个文件来实现数据的交互，读写文件都是通过write read 参数跟绝对路径名来完成。这个文件就是一个管道。
有名管道以文件的形式存在于文件系统中。文件系统也是内核的一部分。

3、信号signal
signal是内核中原本就存在的命令。可以利用kill -l 来查看
在这里插入图片描述
那我们是讲进程间通信的，你给我整这么多命令干嘛？？
信号的处理方式：缺省，忽略，捕获

#include <signal.h>
sighandler_t signal(int signum, sighandler_t handler);
signum信号的类型    handler：信号处理函数/也可以写SIG_DFL缺省,SIG_INT默认

当其它进程使用了signum信号的类型 ，它就会执行 handler：信号处理函数/也可以写SIG_DFL缺省,SIG_INT默认 函数。
实现进程间通信？我不理解。。。
————————————————————————————————

重点：掌握共享内存、消息队列、信号量 这几个都是基于System V IPC的。
IPC 对象包含： 共享内存、消息队列和信号灯集
每个IPC对象有唯一的ID
IPC对象创建后一直存在，直到被显式地删除
每个IPC对象有一个关联的KEY
ipcs / ipcrm

我们在使用共享内存和消息队列信号量的时候，需要关联一个关键字KEY值，来实现同一组key值下面的进程使用
sharememary,Message Queues,signal 方式来实现进程间的通信。
创建关联的key

#include  <sys/types.h>
 #include <sys/ipc.h>
 key_t  ftok(const char *path,  int proj_id);
 成功时返回合法的key值，失败时返回EOF
 path  存在且可访问的文件的路径
 proj_id  用于生成key的数字，范围1-255。

在使用共享内存，消息队列，信号量之前都要创建关联的key。
————————————————————————————————————————————
4、共享内存shareMemary : shmget

共享内存在内核空间创建，被进程的函数接口shmat映射到内存中。在内存中它的访问速度就非常快，进程直接读写内存
由于可能存在多个进程同时访问的请况，因此需要同步和互斥机制。

共享内存的使用步骤：

1）创建共享内存：shareMemary get
 int shmget(key_t key, int size, int shmflg);
 成功时返回共享内存的id，失败时返回EOF
 key  和共享内存关联的key值，IPC_PRIVATE 或 ftok生成
 size 共享内存的大小
 shmflg 共享内存标志位  IPC_CREAT|0666
 
 2}映射共享内存，即把指定的共享内存映射到进程的地址空间用于访问 ：shareMemary attch：触摸粘贴
  void  *shmat(int shmid, const void *shmaddr, int shmflg);
  成功时返回映射后的地址，失败时返回(void *)-1
  shmid   要映射的共享内存id
  shmaddr   映射后的地址， NULL表示由系统自动映射
  shmflg   标志位  0表示可读写；SHM_RDONLY表示只读
  
3）读写共享内存
通过映射的地址段指针访问共享内存

4）使用完之后：撤销共享内存映射  或者进程结束时，会自动撤销映射 shareMemary delete
int  shmdt(void *shmaddr);

5)删除共享内存对象 .不用了时一定要删除的要不然会一直存在
 int  shmctl(int shmid, int cmd, struct shmid_ds *buf); 	//这是共享内存控制函数，把cmd写成删除remid就可以删除共享内存
 shmctl(shmid, IPC_RMID, NULL) ；

代码示例：

wirte.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main(){
	
	key_t key;		//ipc节点
	int shmid;		//共享内存id
	char *addr;		//映射地址
	
	
	key = ftok(".",23);    创建ipc节点 在.（当前目录，你也可以随便选一个绝对路径） key编号为23.
	if(key==-1){
		perror("ftok");
		return -1;
	}
	shmid = shmget(key,1024,IPC_CREAT|0666);	创建共享内存，关联在key值下，共享内存大小为1024权限0666读写
	if(shmid==-1){
		perror("shmget");
		return -1;
	}
	
	addr = shmat(shmid,NULL,0);				映射到内存当中去，0代表自动映射，返回映射地址的指针
	
	fget(addr,32,stdin);					往共享内存当中存放数据
	//strcpy(addr,"this my share memeory");
	
	shmdt(addr);				撤销共享内存
	————————————————————————}
read.c

#include <stdio.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>

int main(){
	key_t key;
	int shmid;
	char *addr;	
	
	key = ftok(".",23);
	if(key==-1){
		perror("ftok");
		return -1;
	}
	shmid = shmget(key,1024,IPC_CREAT|0666);    
	if(shmid==-1){
		perror("shmget");
		return -1;
	}
	由于我们不知道返回的共享内存id是什么，我们可以重新映射遍，对于同一个ftok它会映射在相同的地方。不过你如果
	知道共享内存id（你可以在write的时候打印一下）就可以直接不用上面的操作。不过一般我们是不知道的
	addr = shmat(shmid,NULL,0);
	
	//strcpy(addr,"this my share memeory");
	printf("get share mem=%s\n",addr);  读取共享内存中的数据
	
	
	shmdt(addr);

	shmctl(shmid,IPC_RMID,NULL);
	}

}

————————————————————————————————————
5、消息队列 Message Queues ：msgget
消息队列是存在与内核中的一个队列，这个队列msqid_ds，有唯一的id标识符，并且也要创建ipc，在key值下。
进程可以传递msg_ts的数据结构体放入消息队列中，并通过msqid_ds.msg_first、msg_last维护一个先进先出的msg数据链表。
msg_ts里面有个msg_typ可以用来接收消息的时候也是从msg链表队列尾部查找到一个msg_type匹配的msg节点。
总的来说内核中的队列msqid_ds：里面有msqid_ds.msg_first、msg_last来指向和管理进程传来的msg_ts数据结构体
在这里插入图片描述

消息队列创建方式：
打开/创建消息队列   msgget
msgget(key, IPC_CREAT|0666))
向消息队列发送消息   msgsnd
int msgsnd(int msgid, const void *msgp, size_t size,int msgflg);
从消息队列接收消息   msgrcv
 int msgrcv(int msgid, void *msgp, size_t size, long msgtype,int msgflg);
控制消息队列   msgctl
 int msgctl(int msgid, int cmd, struct msqid_ds *buf);
 cmd    要执行的操作  IPC_STAT / IPC_SET / IPC_RMID

消息队列注意点。
通信双方首先定义好统一的消息格式
用户根据应用需求定义结构体类型
首成员类型必须为long,代表消息类型(正整数)
其他成员都属于消息正文
消息长度不包括首类型 long

演示代码：

msg_send.c
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>
定义通信结构体msg_ts
typedef struct{
	
	long type;
	char txt[64];
}MSG;

#define LEN sizeof(MSG)-sizeof(long) 数据大小

int main(){
	
	key_t ipkey;   ipc的key值
	int msgid;  	消息队列id

	MSG msg_t;		实例化通信结构体
	
    ipkey = ftok(".",23);    创建ipckey值
	if(ipkey==-1){
		perror("ftok");
		return -1;
	}
	msgid = msgget(ipkey,IPC_CREAT|0666);    创建消息队列
	if(msgid ==-1){
		perror("msgget");
		return -1;
	}
	msg_t.type = 1; 		 定义消息类型为1
	strcpy(msg_t.txt,"msg type one");		写数据到通信结构体中
	msgsnd(msgid,&msg_t,LEN,0);		把通信数据结构体写入到消息队列中

	msg_t.type = 2;				定义消息类型为2
	strcpy(msg_t.txt,"msg type two");
	msgsnd(msgid,&msg_t,LEN,0);
	
	msg_t.type = 3;
	strcpy(msg_t.txt,"msg type three");
	msgsnd(msgid,&msg_t,LEN,0);
	
	msg_t.type = 4;
	strcpy(msg_t.txt,"msg type four");
	msgsnd(msgid,&msg_t,LEN,0);
	
	msg_t.type = 5;
	strcpy(msg_t.txt,"msg type five");
	msgsnd(msgid,&msg_t,LEN,0);

写了5个通信结构体在消息队列中
}_________________
msg_recv.c
#include <stdio.h>
#include <signal.h>
#include <sys/types.h>
#include <linux/msg.h>
#include <string.h>
#include <stdlib.h>
定义通信结构体msg_ts
typedef struct{
	long type;
	char txt[64];
}MSG;
int msgid;   消息队列id

#define LEN sizeof(MSG)-sizeof(long)
删除结构体
void rmmsg(int sig){
	
	msgctl(msgid,IPC_RMID,NULL);
	exit(0);
	
}

int main(){
	
	key_t ipkey;
	int re;
	MSG msg_t;
	
    ipkey = ftok(".",23);		构建ipkey值
	if(ipkey==-1){
		perror("ftok");
		return -1;
	}
	msgid = msgget(ipkey,IPC_CREAT|0666);    构造消息队列
	if(msgid ==-1){
		perror("msgget");
		return -1;
	}	
	signal(SIGINT,rmmsg);			信号默认从系统内核中删除消息对列
	
	while(1){
		re = msgrcv(msgid,&msg_t,LEN,3,MSG_EXCEPT);   接收msgid的消息队列 参数二缓冲区地址 接收信息的长度 标志位
		printf("receive msg:type=%d,txt=%s\n",(int)msg_t.type,msg_t.txt);
		if(re<=0){
			break;
		}
	}

我们可以用type来定义不同的通信数据结构体，然后在接收端通过对比type判断是否是我要的数据。
这和内核中iocl的魔数类似。

————————————————————————————————————————————
6、信号量
在前面的内核中共享资源的同步和互斥中里面有锁，也有一个信号量，其实那里的信号量和这里讲的信号量是一个东西。

信号量用于进程间的同步和互斥。给的信号大于1同步，等于1互斥

System V信号灯使用步骤
打开/创建信号灯   semget
 int semget(key_t key, int nsems, int semflg);
  成功时返回信号灯的id，失败时返回-1
  key   和消息队列关联的key  IPC_PRIVATE 或 ftok
  nsems   集合中包含的计数信号灯个数
  semflg   标志位  IPC_CREAT|0666   IPC_EXCL
  
信号灯初始化   semctl
int semctl(int semid, int semnum, int cmd, …);
  成功时返回0，失败时返回EOF
  semid    要操作的信号灯集id
  semnum   要操作的集合中的信号灯编号
  cmd   执行的操作  SETVAL  IPC_RMID
  union  semun      取决于cmd
  
P/V操作   semop

P操作  	信号量减
int semop(int semid, struct sembuf *sops, unsigned nsops);
  成功时返回0，失败时返回-1
  semid    要操作的信号灯集id
  sops    描述对信号灯操作的结构体(数组)
  nsops   要操作的信号灯的个数
  
v操作		信号量加

删除信号灯  semctl

当有进程使用信号量 信号量减一‘ 当有进程释放信号量 信号量加一

示例代码：
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <errno.h>
#include <sys/sem.h>
#include <string.h>

union  semun{
	int val;
};

#define SEM_READ 0
#define SEM_WRITE 0

poperation(int index,int semid){
	struct  sembuf sop;
	sop.sem_num = index;
	sop.sem_op = -1;
	sop.sem_flg = 0;
	semop(semid,&sop,1);
	
}

voperation(int index,int semid){
	struct  sembuf sop;
	sop.sem_num = index;
	sop.sem_op = 1;
	sop.sem_flg = 0;
	semop(semid,&sop,1);	
	
}


int main(){
	
	key_t key;
	int semid;
	int shmid;
	pid_t pid;
	
	char *shmaddr;
	
	key  = ftok(".",123);
	 
	/*创建2个信号灯*/
	semid = semget(key,2,IPC_CREAT|0777);
	if(semid<0){
		perror("semget");
		return -1;
	}

	
	/*创建共享内存*/
	shmid = shmget(key,256,IPC_CREAT|0777);
	if(shmid<0){
		perror("shmget");
		return -1;
	}

7、socket
套接字，在网络上有讲

—————————————————————————————————————————————
进程通信对比：

管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。

有名管道 (named pipe) ： 有名管道也是半双工的通信方式，但是它允许无亲缘关系进程间的通信。

信号量( semophore ) ： 信号量是一个计数器，可以用来控制多个进程对共享资源的访问。它常作为一种锁机制，防止某进程正在访问共享资源时，其他进程也访问该资源。因此，主要作为进程间以及同一进程内不同线程之间的同步手段。

消息队列( message queue ) ： 消息队列是由消息的链表，存放在内核中并由消息队列标识符标识。消息队列克服了信号传递信息少、管道只能承载无格式字节流以及缓冲区大小受限等缺点。

信号 ( sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生。

共享内存( shared memory ) ：共享内存就是映射一段能被其他进程所访问的内存，这段共享内存由一个进程创建，但多个进程都可以访问。共享内存是最快的 IPC 方式，它是针对其他进程间通信方式运行效率低而专门设计的。它往往与其他通信机制，如信号两，配合使用，来实现进程间的同步和通信。

套接字( socket ) ： 套解口也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同及其间的进程通信。

Engineers_wzf
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
常用的几种进程通信方式的比较
03-02
常用的几种进程通信方式的比较常用的几种进程通信方式的比较
进程的通信方式
工匠重生
08-18 416
进程的通信方式     （1）管道（Pipe）：管道可用于具有亲缘关系进程间的通信，允许一个进程和另一个与它有共同祖先的进程之间进行通信。 　　（2）命名管道（named pipe）：命名管道克服了管道没有名字的限制，因此，除具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。命名管道在文件系统中有对应的文件名。命名管道通过命令mkfifo或系统调用mkfifo来创建。 　　（3）信号（
进程间通信的方式及比较
遥远paradise
05-09 476
<br /><br />进程间通信就是在不同进程之间传播或交换信息，那么不同进程之间存在着什么双方都可以访问的介质呢？进程的用户空间是互相独立的，一般而言是不能互相访问的，唯一的例外是共享内存区。但是，系统空间却是“公共场所”，所以内核显然可以提供这样的条件。除此以外，那就是双方都可以访问的外设了。在这个意义上，两个进程当然也可以通过磁盘上的普通文件交换信息，或者通过“注册表”或其它数据库中的某些表项和记录交换信息。广义上这也是进程间通信的手段，但是一般都不把这算作“进程间通信”。因为那些通信手段的效率太低
进程间通信总结
zjhqlmzldx的博客
08-02 467
进程间通信总结 正文 每个进程的用户地址空间都是独立的，一般而言是不能互相访问的，但内核空间是每个进程都共享的，所以进程之间要通信必须通过内核。 Linux 内核提供了不少进程间通信的机制，我们来一起瞧瞧有哪些？ 管道 如果你学过 Linux 命令，那你肯定很熟悉「|」这个竖线。 $ ps auxf | grep mysql 上面命令行里的「|」竖线就是一个管道，它的功能是将前一个命令（ps auxf） 的输出，作为后一个命令（grep mysql）的输入，从这功...
进程间通信方式及比较
solar一抹阳光的专栏
08-26 930
进程间的通信方式：    1.管道（pipe）及有名管道（named pipe）：      管道可用于具有亲缘关系进程间的通信，有名管道除了具有管道所具有的功能外，它还允许无亲缘关系进程间的通信。  2.信号（signal）：      信号是在软件层次上对中断机制的一种模拟，它是比较复杂的通信方式，用于通知进程有某事件发生，一个进程收到一个信号与处理器收到一个中断请求效
Python中的进程间通信
12-20
文章目录Python中的进程间通信1 进程间通信1.1 概念1.2进程间通信方法各种进程间通信1. 基于信号量（Semaphore）的IPC2 基于信号（Signal）的IPC3.基于管道（Pipe）的IPC4. 基于有名管道（fifo）的IPC5.基于消息队列...
C# 进程间通信 共享内存
03-25
共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存，共享内存是两个正在运行的进程之间共享和传递数据的一种非常有效的方式。...1、进程间通信 2、共享内存 3、托管方式与非托管共享内存
C#使用SendMessage实现进程间通信的方法
09-03
在C#编程中，进程间通信（IPC，Inter-Process Communication）是一种允许不同进程之间交换数据的技术。在本文中，我们将探讨如何使用Windows API中的`SendMessage`函数在两个C#进程中实现这一通信方式。 `...
进程通信的方式对比
qq_39078107的博客
09-25 187
文章目录进程通信的方式对比管道消息队列共享内存（mmap, shmget）信号量信号socket 进程通信的方式对比 管道 管道传输数据时单向的。也是以文件的方式存在。 匿名管道： 函数int pipe(int fd[2]) 返回0成功 unistd.h 管道：是内核缓存的一段数据。 mkfifo sys/types.h sys/stat.h 缺点：效率低，不适合进程间频繁额交换数据。 优点：逻辑简单，能更容易知道数据更新 PIP_BUF通常在1024到5120之间 FIFO管道：FIFOwrite具有
进程间数据通信方式比较
蓦然回首
12-02 321
进程间数据通信方式比较 序号 方式 细分 优点 缺点 说明 1 管道 匿名管道 1、自带同步互斥 2、使用比较简单 1、一个管道只提供单向通信，如果实现双向通信需要创建两个管道 2、只能用于相关联的进程，通常用于父子进程 3、写数据时，如果数据没有及时被读取，会发生阻塞；反之，读数据时，如果数据没有写入，也会发生阻塞 ...
进程间的通信方式及区别
weixin_38035852的博客
08-02 1135
1.无名管道（pipe） 特点：最古老的IPC（进程间通信方式） 1.只能用于有血缘关系的进程之间信息传递 2.半双工的信息传递，同一时间只能读或者写，一个方向。固定的读端和写端。 3.独立于文件系统之外，不属于文件系统，特别的方式存在于内存中。   2.命名管道（FIFO） 1.克服了无名管道的只能有血缘关系进程之间的通信，无关进程之间也可以通信。 2.以一种特殊的文件格式存在于...
进程间通讯方式及区别
liuziyuan333183的博客
03-09 465
1.管道pipe 一般不用匿名管道做进程通信，使用2 2.命名管道FIFO 推荐使用，和socket相比，不占用端口号，虽然也支持不同机器通信，但一般只用于本机进程通信，支持数据双向或单向传输 3.内存映射MemoryMapping 适用于共享数据的情况，与管道和socket相比，缺点是不能被动得到通知，只能主动去访问共享数据。假如有A,B两个进程，A修改或读取共享内存的数...
进程和线程的区别及通信方式
chisenna4965的博客
08-31 691
根本区别：进程是操作系统资源分配的基本单位，线程是任务调度和执行的基本单位。 在开销方面：每个进程都有独立的代码和数据空间（程序上下文），程序之间的切换会有较大的开销；线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销...
【C++实习生】每天十道面试题打卡
0泡果奶的博客
03-07 440
第十天，还剩两个星期不到，冲冲冲。
Linux进程间通信(IPC)编程实践（三） 详解System V消息队列(1)
zjy900507的博客
04-26 209
消息队列简介消息队列提供了一个从一个进程向另外一个进程发送一块数据的方法（本机）;每个数据块都被认为是有一个类型，接收者进程接收的数据块可以有不同的类型值。消息队列也有管道一样的不足: (1)每个消息的最长字节数的上限（MSGMAX）; (2)系统中消息队列的总条数也有一个上限（MSGMNI）; (3)每个消息队列所能够保存的总字节数是有上限的（MSGMNB） . 消息队列与管道的区别：最主要的区...
算法基础知识【3】（8-11）
Jasminexjf的博客
08-11 4948
Date: 2019-08-11 1. 算法的空间复杂度是指（）。算法空间复杂度指的是算法 执行过程中需要占用多少内存空间资源 回顾：算法的时间复杂度 2. 在索引顺序表中，实现分块查找，在等概率查找情况下，其平均查找长度不仅与表中元素个数有关，而且与每块中元素个数有关。（） 正确 解释：在分块查找过程中，先对块间进行顺序查找，然后对每个块内进行查找（有时采用二分查找） 3. 下列...
2013谷歌首批笔试题【京，转自同学】
iteye_4701的博客
10-18 221
  昨天晚上去蹭了一下Google的招聘笔试。其实是去打酱油的，主要是为了感受一下Google的出题风格和考试氛围，可以对将来找工作提供些参考。 回来之后本来想回忆一下题目的，结果发现braveheart89大大已经贴出了所有的题而且连选项都一字不差，记忆力真心佩服……以下就根据他写的题目稍微修正一下[1]，然后随便说说好了。（说的也不一定对，欢迎更正。） 考试是第一页需要填...
Python进程间通信
最新发布
02-20
Python进程间通信是指在多个Python进程之间进行交换和共享的机制。Python提供了多种进程间通信的方式，包括管道、消息队列、共享内存和套接字等。 1. 管道（Pipe）：管道是一种半双工的通信方式，可以在父进程和子进程之间传递数据。在Python中，可以使用`multiprocessing`模块中的`Pipe`类来创建管道。 2. 消息队列（Queue）：消息队列是一种进程间通信的方式，可以实现多个进程之间的数据传递。Python中的`multiprocessing`模块提供了`Queue`类来实现消息队列。 3. 共享内存（Shared Memory）：共享内存是一种高效的进程间通信方式，可以让多个进程共享同一块内存区域。Python中的`multiprocessing`模块提供了`Value`和`Array`等类来实现共享内存。 4. 套接字（Socket）：套接字是一种网络编程中常用的进程间通信方式，可以在不同主机上的进程之间进行通信。Python中的`socket`模块提供了套接字编程的接口，可以用于实现进程间通信。 以上是Python中常用的进程间通信方式，根据具体的需求和场景选择合适的方式进行进程间通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值