网络IO管理

已于 2023-08-28 19:40:13 修改
阅读量99 收藏
点赞数
文章标签： 网络 网络协议 tcp
于 2023-08-28 18:06:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41896869/article/details/132516175
版权

文章目录

前言

网络IO模型讲解，包括原始的socket编程，多线程、select轮询、epoll以及reactor的网络编程。

一、原始socket编程

socket编程的流程具体可以看我的blog：https://editor.csdn.net/md/?articleId=131496108
原生的socket编程，其中的大部分接口都是阻塞的。
这里直接贴出代码：

nt main() {

// block
	int listenfd = socket(AF_INET, SOCK_STREAM, 0);  // 
	if (listenfd == -1) return -1;
// listenfd
	struct sockaddr_in servaddr;
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(9999);

	if (-1 == bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) {
		return -2;
	}
    printf("这里没有阻塞0；\n");
	listen(listenfd, 10);

#if 1
	// int 
	struct sockaddr_in client;
	socklen_t len = sizeof(client);
    printf("这里没有阻塞1；\n");
	int clientfd = accept(listenfd, (struct sockaddr*)&client, &len);       // 默认是阻塞的
    printf("这里没有阻塞2；\n");
    int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
	if (ret == 0) {
		close(clientfd);
		break;
	}
	printf("buffer : %s, ret: %d\n", buffer, ret);
	ret = send(clientfd, buffer, ret, 0); // 
	```
若要将accept接口改为非阻塞的方式，在listen监听之前设置属性，修改代码为：
```javascript
#if 1 // nonblock
	int flag = fcntl(listenfd, F_GETFL, 0);
	flag |= O_NONBLOCK;
	fcntl(listenfd, F_SETFL, flag);
#endif

二、多线程socket

以上原生的socket代码出现的问题主要就是仅仅允许一个客户端连接，因此引入多线程的方法。
IO多线程基本的模型：
在这里插入图片描述

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <unistd.h>
#include <pthread.h>
#define BUFFER_LENGTH	128

// thread --> fd
void *routine(void *arg) {

	int clientfd = *(int *)arg;

	while (1) {
		
		unsigned char buffer[BUFFER_LENGTH] = {0};
        // recv & send
		int ret = recv(clientfd, buffer, BUFFER_LENGTH, 0);
		if (ret == 0) {
			close(clientfd);
			break;
			
		}
		printf("buffer : %s, ret: %d\n", buffer, ret);

		ret = send(clientfd, buffer, ret, 0); // 

	}

}

// socket --> 
// bash --> execve("./server", "");
// 
// 0, 1, 2
// stdin, stdout, stderr
int main() {

// block
	int listenfd = socket(AF_INET, SOCK_STREAM, 0);  // 
	if (listenfd == -1) return -1;
// listenfd
	struct sockaddr_in servaddr;
	servaddr.sin_family = AF_INET;
	servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(9999);

	if (-1 == bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr))) {
		return -2;
	}

#if 0 // nonblock
	int flag = fcntl(listenfd, F_GETFL, 0);
	flag |= O_NONBLOCK;
	fcntl(listenfd, F_SETFL, flag);
#endif
    printf("这里没有阻塞0；\n");
	listen(listenfd, 10);

#if 1
	// int 
	struct sockaddr_in client;
	socklen_t len = sizeof(client);
    printf("这里没有阻塞1；\n");
	int clientfd = accept(listenfd, (struct sockaddr*)&client, &len);       // 默认是阻塞的
    
	//printf("sendbuffer : %d\n", ret);
#else

	while (1) {
		struct sockaddr_in client;
		socklen_t len = sizeof(client);
		int clientfd = accept(listenfd, (struct sockaddr*)&client, &len);
		
		pthread_t threadid;
		pthread_create(&threadid, NULL, routine, &clientfd);	// 需要执行的线程以及参数传递
		//fork();
	}
#endif

}

使用多线程的优势以及劣势：
优势：实现逻辑简单；
劣势：1.系统开销大；2.有数量限制

三、select轮询

  使用文件描述符集合来管理被监视的文件描述符.io是否有事件，其中的事件是 可读/可写。其中网络的fd 0 1 2是stdin、stdout以及stderr这三个最基本的fd句柄数字。本质：是一个IO管理组建
通过select函数依次轮询这些文件描述符的集合是否就绪，如果就绪则返回，否则阻塞。
相关api：
FD_ISSET：判断fd文件是否在数据集合中；
FD_SET：将fd文件添加到数据集合中；
FD_CLR：将fd文件从数据集合中删除；

while (1) {

		rset = rfds;    //
		wset = wfds;

		int nready = select(maxfd+1, &rset, &wset, NULL, NULL);     // 阻塞   rset 和 wset 集合中已经有文件描述符就绪，即至少有一个文件描述符可读或可写的时候返回
		if (FD_ISSET(listenfd, &rset)) {    // 检查读集合中是否设置 文件描述符listenfd

			printf("listenfd --> \n");

			struct sockaddr_in client;
			socklen_t len = sizeof(client);
			int clientfd = accept(listenfd, (struct sockaddr*)&client, &len);   // accept接受
			
			FD_SET(clientfd, &rfds);    // 设置可读事件进入 clientfd

			if (clientfd > maxfd) maxfd = clientfd;
		} 
		
		int i = 0;
		for (i = listenfd+1; i <= maxfd;i ++) {

			if (FD_ISSET(i, &rset)) {   //

				ret = recv(i, buffer, BUFFER_LENGTH, 0);
				if (ret == 0) {
					close(i);
					FD_CLR(i, &rfds);
					
				} else if (ret > 0) {
					printf("buffer : %s, ret: %d\n", buffer, ret);
					FD_SET(i, &wfds);   // 将文件描述符i添加进入可写事件中
				}
				
			} else if (FD_ISSET(i, &wset)) {          //
				
				ret = send(i, buffer, ret, 0);    // 发送buffer数据
				
				FD_CLR(i, &wfds);   // 清空wfds
				FD_SET(i, &rfds);
			}
		}

select 的优点：

  1. 跨平台支持：select 在几乎所有操作系统上都有实现，具备较好的跨平台特性。
  2. 简单易用：使用简单，学习成本低，适用于简单的并发网络编程。
  3. 支持文件描述符集合：select 使用文件描述符集合来管理被监视的文件描述符

select 的缺点：

  1. 性能问题：select 将监视的文件描述符集合从用户空间传递到内核空间，并且每次调用 select 都需要线性扫描整个文件描述符集合，效率较低。
  2. 限制连接数：select 的文件描述符集合大小有限，通常默认为 1024 或更小。
  3. 每次调用 select 都需要重新设置文件描述符集合，效率较低。

四、epoll事件通知

  高性能的事件驱动I/O（Input/Output）模型，用于处理大规模并发连接的网络编程。它通过提供一个事件驱动的接口，使得应用程序能够高效地等待多个文件描述符上的事件，并进行相应的处理。本质：高性能IO管理组件
模型图：
在这里插入图片描述

常用接口介绍：
eventpoll包括红黑树和双向链表，在内核态。
epoll_create:创建epoll实例，包括RB-tree（相当于红黑树的head节点）以及rbllist；
epoll_ctl: 向红黑树注册感兴趣的fd；
epoll_wait:轮询rbllist，存储的是就绪的fd，如果不为空则返回，将数据传送到应用层，否则阻塞。通过copy的方式

// fd --> epoll 
	int epfd = epoll_create(1);

	struct epoll_event ev, events[EVENTS_LENGTH];
	ev.events = EPOLLIN;
	ev.data.fd = listenfd; //

	epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev); // 
	

	while (1) { // 7 * 24 

		int nready = epoll_wait(epfd, events, EVENTS_LENGTH, -1); // -1, ms 
		printf("------- %d\n", nready);
		
		int i = 0;
		for (i = 0;i < nready;i ++) {
			int clientfd= events[i].data.fd;
			
			if (listenfd == clientfd) { // accept

				//while(1) {
					struct sockaddr_in client;
					socklen_t len = sizeof(client);
					int connfd = accept(listenfd, (struct sockaddr*)&client, &len);
					if (connfd == -1) break;
					
					printf("accept: %d\n", connfd);
					ev.events = EPOLLIN;
					ev.data.fd = connfd;
					epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
				//}
			

			} else if (events[i].events & EPOLLIN) { //clientfd

				//char rbuffer[BUFFER_LENGTH] = {0};

				int n = recv(clientfd, rbuffer, BUFFER_LENGTH, 0);
				if (n > 0) {
					//rbuffer[n] = '\0';

					printf("recv: %s, n: %d\n", rbuffer, n);

					memcpy(wbuffer, rbuffer, BUFFER_LENGTH);

					ev.events = EPOLLOUT;
					ev.data.fd = clientfd;

					epoll_ctl(epfd, EPOLL_CTL_MOD, clientfd, &ev);
					
				} 
				
			} else if (events[i].events & EPOLLOUT) {

				
				int sent = send(clientfd, wbuffer, BUFFER_LENGTH, 0); //
				printf("sent: %d\n", sent);

				ev.events = EPOLLIN;
				ev.data.fd = clientfd;

				epoll_ctl(epfd, EPOLL_CTL_MOD, clientfd, &ev);
				
				
			}

		}

	}

五、Reactor反应堆网络模型

  本质：Reactor 逆置了事件处理流程，应用程序需要提供相应的接口并注册到 Reactor 上，如果相应的时间发生，Reactor 将主动调用应用程序注册的接口，这些接口又称为“回调函数”。
  中心思想：处理的 I/O 事件注册到一个中心 I/O 多路复用器上。一旦有 I/O 事件到来或是准备就绪(文件描述符或 socket 可读、写)，多路复用器返回并将事先注册的相应 I/O 事件分发到对应的处理器中。
模型架构：
在这里插入图片描述

主函数：

int main(int argc, char *argv[]) {

	
	struct ntyreactor *reactor = (struct ntyreactor*)malloc(sizeof(struct ntyreactor));
	ntyreactor_init(reactor);

	unsigned short port = SERVER_PORT;
	if (argc == 2) {
		port = atoi(argv[1]);
	}

	int i = 0;
	int sockfds[PORT_COUNT] = {0};
	
	for (i = 0;i < PORT_COUNT;i ++) {
		sockfds[i] = init_sock(port+i);
		ntyreactor_addlistener(reactor, sockfds[i], accept_cb);     // 注册函数的流程
	}


	ntyreactor_run(reactor);

	ntyreactor_destory(reactor);
	
	for (i = 0;i < PORT_COUNT;i ++) {
		close(sockfds[i]);
	}
	free(reactor);
	

	return 0;
}

Reactor结构体以及初始化Reactor模型的步骤 ：

struct ntyevent {
	int fd;         // 待操作的文件描述符
	int events;
	void *arg;
	int (*callback)(int fd, int events, void *arg);
	
	int status;
	char buffer[BUFFER_LENGTH];
	
	char wbuffer[BUFFER_LENGTH];
	
	int length;
	int wlength;
	//long last_active;

	// http reqeust
	int method;
	char resource[RESOURCE_LENGTH];

};

struct eventblock {
	
	struct eventblock *next;
	struct ntyevent *events;
};

struct ntyreactor {
	int epfd;       // epoll实例
	int blkcnt;		// 容量块

	struct eventblock *evblks;
};
// 初始化函数：
int ntyreactor_init(struct ntyreactor *reactor) {

	if (reactor == NULL) return -1;
	memset(reactor, 0, sizeof(struct ntyreactor));

	reactor->epfd = epoll_create(1);	// 创建epoll实例
	if (reactor->epfd <= 0) {
		printf("create epfd in %s err %s\n", __func__, strerror(errno));
		return -2;
	}

	struct ntyevent* evs = (struct ntyevent*)malloc((MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));	//多个 eventitem，容量为MAX_EPOLL_EVENTS
	if (evs == NULL) {
		printf("create epfd in %s err %s\n", __func__, strerror(errno));
		close(reactor->epfd);
		return -3;
	}
	memset(evs, 0, (MAX_EPOLL_EVENTS) * sizeof(struct ntyevent));

	struct eventblock *block = malloc(sizeof(struct eventblock));
	if (block == NULL) {
		free(evs);
		close(reactor->epfd);
		return -3;
	}
	block->events = evs;
	block->next = NULL;

	reactor->evblks = block;
	reactor->blkcnt = 1;

	return 0;
}

注册函数，采用回调的方式：

int ntyreactor_addlistener(struct ntyreactor *reactor, int sockfd, NCALLBACK *acceptor) {

	if (reactor == NULL) return -1;
	if (reactor->evblks == NULL) return -1;

	struct ntyevent *event = ntyreactor_idx(reactor, sockfd);	// 根据sockfd的值找到对应分配的 event 数据
	if (event == NULL) return -1;
    // 以下是事件派发的逻辑   dispatch
	nty_event_set(event, sockfd, acceptor, reactor);	// event的 的设置   acceptor回调函数的注册
	nty_event_add(reactor->epfd, EPOLLIN, event);		// ADD EPOLLIN   调用epoll_ctl 首先

	return 0;
}

void nty_event_set(struct ntyevent *ev, int fd, NCALLBACK callback, void *arg) {

	ev->fd = fd;
	ev->callback = callback;
	ev->events = 0;
	ev->arg = arg;
	//ev->last_active = time(NULL);

	return ;
	
}

int nty_event_add(int epfd, int events, struct ntyevent *ev) {

	struct epoll_event ep_ev = {0, {0}};
	ep_ev.data.ptr = ev;
	ep_ev.events = ev->events = events;
    // 初始化的时候为0
	int op;
	if (ev->status == 1) {
		op = EPOLL_CTL_MOD;
	} else {
		op = EPOLL_CTL_ADD;
		ev->status = 1;     // 改为1
	}

	if (epoll_ctl(epfd, op, ev->fd, &ep_ev) < 0) {
		printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
		return -1;
	}

	return 0;
}

等待事件的发生：

int ntyreactor_run(struct ntyreactor *reactor) {
	if (reactor == NULL) return -1;
	if (reactor->epfd < 0) return -1;
	if (reactor->evblks == NULL) return -1;
	
	struct epoll_event events[MAX_EPOLL_EVENTS+1];
	
	int checkpos = 0, i;

	while (1) {

		int nready = epoll_wait(reactor->epfd, events, MAX_EPOLL_EVENTS, 1000);
		if (nready < 0) {
			printf("epoll_wait error, exit\n");
			continue;
		}

		for (i = 0;i < nready;i ++) {

			struct ntyevent *ev = (struct ntyevent*)events[i].data.ptr;

			if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) {   // 这两个判断是什么意思  第二个是事件item中的
				ev->callback(ev->fd, events[i].events, ev->arg);
			}
			if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) {
				ev->callback(ev->fd, events[i].events, ev->arg);
			}
			
		}

	}
}

accept、recv以及send均以回调的方式实现，这里就不贴出代码了，accept_cb的逻辑完成之后，再设置事件的回调函数为recv_cb,当recv_cb的逻辑完成后会更新event为send_cb依此往复。
epoll实现Reactor模型的流程总结：

  1. socket的流程；
  2. reactor数据成员的初始化；epoll_create 创建epfd
  3. 注册accept_cb回调函数;
  4. 注册socketefd到reactor中的epollfd实例；
  5. epoll_wait循环等待事件通知，+相关业务处理recv/send；
  6. 关闭文件描述符epfd、sockfd；清除reactor等内存；
huermosy
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算机网络IO模型
Mr.xing的博客
02-15 2508
IO一般指访问磁盘数据的次数，IO操作分为输入(读取)和输出(写入)两种类型，网络IO也一样，只不过它读取的不是磁盘而是socket。然后有多种读取的方式，常见的有：AIO异步非阻塞(Asynchronous IO)、异步阻塞(多路复用IO Multiple)、NIO同步非阻塞(Non-blocking IO)、BIO同步阻塞Blocking IO)，服务器端编程构造高性能的IO模型必备的几种。
网络编程+IO实现快递管理系统
01-20
这是完整的项目资源包，主要是针对本地文件的存储小系统。我不知道有啥bug，希望大家指正
网络IO概述
云原生Java Web领域技术博客
11-13 1949
现在计算机的发展离不开网络，特别是分布式应用(本质上就是计算机+网络)，本文重点关注常见的网络IO模型以及经典的IO多路复用几种实现方式(select、poll、epoll)的比较，方便后续网络 IO 编程。
Zookeeper-网络IO管理器ServerCnxnFactory
pfjia的博客
06-25 2581
背景 ServerCnxnFactory NIOServerCnxnFactory 启动 accept thread 处理请求 NettyServerCnxnFactory 总结 参考 背景 Zookeeper作为一个服务器,自然要与客户端进行网络通信,如何高效的与客户端进行通信,让网络IO不成为ZooKeeper的瓶颈是ZooKeeper急需解决的问题,ZooKeepe...
03 Redis 网络IO模型简介
热门推荐
一个天秤座的架构师
02-11 2万+
1Redis中的单线程模型 提起Redis，我们经常会说其底层是一个单线程模型，但这是不严谨的。Redis单线程指的是网络请求模块使用了一个线程，即一个线程处理所有网络请求，其他模块该使用多线程，仍会使用了多个线程。既然是单线程模型，那么CPU不是Redis的瓶颈。Redis的瓶颈最有可能是机器内存或者网络带宽。 2Redis中的单线程模型 Redis基于Reactor模式开发了自己的网络事件处理器，称之为文件事件处理器(File Event Hanlder)。文件事件处理...
网络IO流
qq_56754651的博客
08-04 1000
是什么？ 流其实就是一系列的数据（分字节流字符流，其实计算机底层识别到的都是二进制数据）。IO流我理解为就是一系列数据在网络之间输入/输出相互交流传递的过程。现实的例子：张三想要从成都传送到北京；那么张三要先进行准备，去传送点，在传输的过程中，只能作为数据（具体怎么传送可以参考影视资料）传送到目的地的相应位置，由北京的那边的专业机构来接收他。在传送的准备-->传送-->接收 整个过程中，就是IO流的实现过程。
网络IO的理解
JineD的博客
10-19 6828
Unix/Linux系统下IO主要分为磁盘IO，网络IO，我今天主要说一下对网络IO的理解，网络IO主要是socket套接字的读(read)、写(write)，socket在Linux系统被抽象为流(stream)。 网络IO模型 在Unix/Linux系统下，IO分为两个不同阶段： 等待数据准备好 从内核向进程复制数据 阻塞式I/O 阻塞式I/O(blocking I/O)是最简单的一种，默认情况下，socket 套接字的系统调用都是阻塞的，我以recv/recvfrom 理解一下网络IO的模型
（二）NIO之网络IO
BestQiang的博客
05-28 1万+
概述和核心 API 前面在进行文件 IO 时用到的 FileChannel 并不支持非阻塞操作，学习 NIO 主要就是进行网络 IO，Java NIO 中的网络通道是非阻塞 IO 的实现，基于事件驱动，非常适用于服务器需要维持大量连接，但是数据交换量不大的情况，例如一些即时通信的服务等等 在 Java 中编写 Socket 服务器，通常有以下几种模式： 一个客户端连接用一个线程，优点：程序编写简...
网络IO之NIO
morris
11-09 2万+
网络IO之NIO NIO库是在JDK1.4中才引入，弥补了原来的I/O（BIO）的不足，它是一个高速的、面向块的I/O。 NIO有两层含义： 在java层面：nio称为new io，是一套全新的操作io的api。 在OS层面：nio称为no-blocking io，系统调用socket函数可以设置一个NONBLOCK的参数，实现调用方法时不会阻塞线程。 与BIO的主要区别 面向流与面向缓冲 BIO是面向流的，面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能
Linux系统运行时参数命令--网络IO性能监控
kakaka666的博客
12-28 3300
Linux系统运行时参数命令--网络IO性能监控
网络io，磁盘io,线程池解决思想
weixin_57711380的博客
06-21 1521
网络io，磁盘io一些知识点。
IO管理 5.1IO管理概述1
08-03
引入中断机制；IO速度慢，当CPU发出读写命令后，将等待IO的进程阻塞，切换到别的进程指向，中断机制允许I/O设备控制器发出中断信号主动打断CPU的运行并请求服
PROFINET IO 网络拓扑
02-02
设备操作在 PROFINET 拓扑环境中，必须支持简单网络管理协议（SNMP），链路层发现协 议(LLDP)，物理设备(PDEV)，发现和组态协议(DCP)。其中 PDEV 来源于 PNO 标准的以太 网接口/端口描述。其中包括 IP/MAC 地址，...
Java个人资产管理系统、网络IO多线程、反射
12-06
通过手撕网络IO多线程实现服务端与客户端分离的小项目，服务获取是反射实现的，带你深度体会4行代码操控整个service层。客户端是命令行，服务器是带界面的。有双击运行的bat文件。数据库默认账号密码都是root。...
通信与网络中的GE Fanuc智能平台发布COTS VXS串行高速IO管理交换机
11-29
CRX800为多处理应用设计，支持VITA 41.222 个x4串行高速IO端口（18个负载端口，4个内部交换端口）每线最高速度达3.125Gbits每秒六个加固等级提供对AXIS先进多处理器集成软件的最佳支持串行高速IO管理交换机 ，GE ...
Java网络编程(上)
最新发布
qq_34471880的博客
06-01 816
数据在网络的传输, 局域网的概念, 广域网的概念, 网络协议, TCP五层模型, 网络封装 网络分用
冶炼钢铁厂热风炉发酵池煤矸石进回水无线远程温度监测
weixin_46970383的博客
05-30 299
Modbus RTU 标准Modbus-RTU通信协议。Modbus RTU使用二进制格式传输数据，并使用串行通信协议（如RS-232或RS-485）进行数据传输。它通常用于连接不同厂家的可编程逻辑控制器（PLC）、传感器、执行器和其他自动化设备。
note-网络是怎样连接的4 接入网和网络运营商
qq_42783188的博客
05-29 413
在BAS和运营商路由器之间的ADSL/FTTH接入服务商的网络中建立隧道，把用户到BAS的接入网连接起来，形成一条从用户一直到运营商路由器的通道。这些状况不是稳定出现的。一方路由器让相连的运营商的路由器告知路由信息后，就能知道对方路由器连接的所有网络，把这些信息写入自己的路由表中，就能向那些网络发送包了。运营商之间的路由交换是在特定路由器间一对一进行的，运营商可以只将路由信息提供给交了费的运营商，没交费的运营商无法将网络包发送过来。Modem产生的信号是以一定周期振动的波，振动的起始位置不同，波形就不同。
解密网络流量监控：优化IT运维的利器
Johnstons的博客
05-29 341
通过实时监测和分析网络流量，管理员可以及时发现并解决网络问题，确保业务的顺畅进行。作为一名资深网络工程师，我将分享一些关于网络流量监控的重要知识，并探讨如何在IT运维中运用这一工具优化网络性能，确保业务的顺畅进行。网络流量监控是指对网络中的数据流进行实时监测和分析，以了解网络使用情况、性能状况和潜在问题。通过网络流量监控，可以及时发现网络拥塞、异常流量和安全威胁，帮助管理员快速做出反应，保障网络的稳定运行。定期对监控数据进行分析，发现网络性能问题的潜在原因，并采取相应的优化措施，从而持续提升网络性能。
python管理网络代码
03-13
下面是一些常见的Python网络编程库和模块，可以帮助你管理网络代码： 1. socket模块：Python的socket模块提供了底层的网络通信功能，可以创建套接字并进行网络通信。你可以使用socket模块来实现基本的网络连接、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值