socket非阻塞模式服务器设计与实现

最新推荐文章于 2023-04-01 21:28:28 发布
最新推荐文章于 2023-04-01 21:28:28 发布
阅读量2k 收藏 5
点赞数
分类专栏： Socket编程 文章标签： socket 服务器 阻塞 非阻塞 代码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18297675/article/details/53163591
版权

==> 学习汇总（持续更新）
==> 从零搭建后端基础设施系列（一）-- 背景介绍

阻塞和非阻塞的区别就是一个阻塞等待，一个直接返回，并返回一些有意义的错误代码。

跳转到代码

思路如下：
1.初始化套接字

2.创建套接字

3.设置socket为非阻塞模式

int ioctlsocket(
  SOCKET s,    //要设置的套接字
  long cmd,    //FIONBIO
  u_long FAR* argp  //非零值
);

注： 关于第二第三个参数，MSDN是这样解释的：

Use FIONBIO with a nonzero argp parameter to enable the nonblocking mode of socket s. The argp parameter is zero if nonblocking is to be disabled. The argp parameter points to an unsigned long value. When a socket is created, it operates in blocking mode by default (nonblocking mode is disabled).
大概意思就是第二个参数为FIONBIO的时候，第三个参数设置为非0值，则表示此套接字被设置为非阻塞模式，0就表示阻塞模式。当一个套接字创建的时候默认是阻塞的。

4.绑定服务器

5.监听

6.接受客户端请求

这一步和阻塞模式的就开始有区别了（前面的操作都不会返回WSAEWOULDBLOCK错误代码），因为accept函数不再阻塞的等待一个连接到来，而是立即返回一个错误代码。

7.接收/发送数据

这一步也和阻塞模式有区别，它们也是直接返回而不在阻塞等待。所以，我们需要根据返回的错误码来判断。

缺点：需要用一个while循环，不断的判断是否有数据到来，是否可以发送数据，对CPU消耗很大。（可以通过sleep函数进行控制循环速度，这样可以减小CPU消耗）

实例：

server.cpp

#include "server.h"

int main()
{
	SOCKET sServer = INVALID_SOCKET;
	SOCKET sClient = INVALID_SOCKET;
	SOCKADDR addrClient = { 0 };
	DWORD dwError = 0;
	if (OpenTCPServer(&sServer,18000, 1,&dwError))  //打开服务器
	{
		if (AcceptClient(sServer, &sClient, &addrClient, sizeof(addrClient)))//接受请求
		{
			ShowMessage((SOCKADDR_IN*)&addrClient);                   //显示连接信息函数
			_beginthreadex(NULL, 0, ThreadRecv,&sClient, 0, NULL);    //开启接收和发送数据函数
			_beginthreadex(NULL, 0, ThreadSend, &sClient, 0, NULL);
		}
	}
	Sleep(10000000); //主线程睡眠
	return 0;
}

client.cpp

#include "client.h"

int main()
{
	SOCKET sClient = INVALID_SOCKET;
	SOCKADDR_IN addrServer = { 0 };
	DWORD dwError = 0;
	addrServer.sin_family = AF_INET;      //设置server地址
	addrServer.sin_port = 18000;
	addrServer.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
	if (InitSocket(&sClient,addrServer,&dwError,1))  //初始化套接字
	{ 
		if (ConnectServer(&sClient, addrServer))     //连接服务器
		{
			ShowMessage(((SOCKADDR_IN*)&addrServer));//显示连接信息 
			_beginthreadex(NULL, 0, ThreadRecv, &sClient, 0, NULL);  //开启接收和发送线程
			_beginthreadex(NULL, 0, ThreadSend, &sClient, 0, NULL);
		}	
	}
	Sleep(10000000); //主线程睡眠
	return 0;
}

server.h

#ifndef _SERVER_H_
#define _SERVER_H_

#include <windows.h>
#include <process.h>
#include <stdio.h>
#include <conio.h>
#pragma comment(lib,"ws2_32.lib")
#define MAXBUF 126

/*
@function OpenTCPServer             打开TCP服务器
@param  _Out_ SOCKET* sServer		客户端套接字
@param _In_ unsigned short Port     服务器端口
@param  _In_ unsigned long block         0为阻塞，非0为非阻塞
@param  _Out_ DWORD* dwError               错误代码
@return  成功返回TRUE 失败返回FALSE
*/
BOOL OpenTCPServer(_Out_ SOCKET* sServer, _In_ unsigned short Port, _In_ unsigned long block, _Out_ DWORD* dwError)
{
	BOOL bRet = FALSE;
	WSADATA wsaData = { 0 };
	SOCKADDR_IN ServerAddr = { 0 };
	ServerAddr.sin_family = AF_INET;
	ServerAddr.sin_port = Port;
	ServerAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
	do
	{
		if (!WSAStartup(MAKEWORD(2, 2), &wsaData))
		{
			if (LOBYTE(wsaData.wVersion) == 2 || HIBYTE(wsaData.wVersion) == 2)
			{
				*sServer = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
				if (ioctlsocket(*sServer, FIONBIO, (unsigned long*)&block) != SOCKET_ERROR)
				{
					if (*sServer != INVALID_SOCKET)
					{
						if (SOCKET_ERROR != bind(*sServer, (SOCKADDR*)&ServerAddr, sizeof(ServerAddr)))
						{
							if (SOCKET_ERROR != listen(*sServer, SOMAXCONN))
							{
								bRet = TRUE;
								break;
							}
							*dwError = WSAGetLastError();
							closesocket(*sServer);
						}
						*dwError = WSAGetLastError();
						closesocket(*sServer);
					}
					*dwError = WSAGetLastError();
				}
				*dwError = WSAGetLastError();
			}
		}
		*dwError = WSAGetLastError();
	} while (FALSE);
	return bRet;
}

/*
@function AcceptClient              接受客户端连接请求
@param  _In_ SOCKET sServer		    server套接字
@param  _Out_ SOCKET* sClient       client套接字
@param  _Out_ SOCKADDR* ClientAddr  client地址
@param  _In_ int iClientAddrSize    client地址大小
@return  成功返回TRUE 失败返回FALSE
*/
BOOL AcceptClient(_In_ SOCKET sServer, _Out_ SOCKET* sClient, _Out_ SOCKADDR* ClientAddr, _In_ int iClientAddrSize)
{
	DWORD dwError = 0;
	do
	{
		*sClient = accept(sServer, (SOCKADDR*)ClientAddr, &iClientAddrSize);
		if (*sClient == INVALID_SOCKET)
		{
			dwError = WSAGetLastError();
			if (dwError == WSAEWOULDBLOCK)  //还没收到连接请求
				Sleep(100);
		}
	} while (*sClient == INVALID_SOCKET);
	return TRUE;
}

/*
@function RecvData                  接收数据函数
@param  _In_ SOCKET s				套接字
@param  _Out_ char* buf				接收数据缓冲区
@param  _In_ int iSize				缓冲区大小
@return  返回接收到的数据大小
*/
int RecvData(_In_ SOCKET s, _Out_ char* buf, _In_ int iSize)
{
	int iRemain = iSize;  //剩余字节
	int iCur = 0;         //当前读取到的字节
	int iLen = 0;
	while (iRemain)
	{
		iLen = recv(s, &buf[iCur], iSize, 0);
		if (iLen == SOCKET_ERROR)            //这里不用判断WSAEWOULDBLOCK错误代码
			break;
		iCur += iLen;
		iRemain = iSize - iLen;  //求出还剩余多少字节没有读完
	}
	return iCur;
}

/*
@function RecvData                  发送数据函数
@param  _In_ SOCKET s				套接字
@param  _In_ char* buf				发送的数据
@param  _In_ int iSize				数据大小
@return  返回接收到的数据大小
*/
int SendData(_In_ SOCKET s, _In_ char* buf, _In_ int iSize)
{
	int iRemain = iSize;  //剩余字节
	int iCur = 0;         //当前发送的字节
	int iLen = 0;
	while (iRemain)
	{
		iLen = send(s, &buf[iCur], iSize, 0);
		if (iLen == SOCKET_ERROR)
		{
			DWORD dwError = GetLastError();
			if (dwError == WSAEWOULDBLOCK)
				continue;
			else                  //其它错误
				return -1;
		}
		iCur += iLen;
		iRemain = iSize - iLen;  //求出还剩余多少字节没有发送
	}
	return iCur;
}

//接收数据线程
unsigned int __stdcall ThreadRecv(void* lparam)
{
	char buf[MAXBUF] = { 0 };
	int iRet = 0;
	while (1)
	{
		Sleep(100);   //这个一定要放在接收数据函数之前，否则一直循环，会导致CPU狂涨
		iRet = RecvData(*(SOCKET*)lparam, buf, MAXBUF);
		if (iRet == 0)
			continue;
		printf("Recv:%s\n", buf);
		memset(buf, 0, MAXBUF);
	}
	return 0;
}

//发送数据线程
unsigned int __stdcall ThreadSend(void* lparam)
{
	char buf[MAXBUF] = { 0 };
	while (1)
	{
		int c = getch();
		if (c == 72 || c == 0 || c == 68)//为了显示美观，加一个无回显的读取字符函数
			continue;
		memset(buf, 0, MAXBUF);
		printf("Send:");
		gets_s(buf);
		if (strlen(buf) == 0)
			continue;
		SendData(*(SOCKET*)lparam, buf, strlen(buf) + 1);  //发送数据
		Sleep(100);
	}
	return 0;
}

//显示信息函数
void ShowMessage(SOCKADDR_IN* addr)
{
	printf("Success accept a connect from IP: %s,port: %d\n", inet_ntoa(addr->sin_addr), htons(addr->sin_port));
}


#endif //_SERVER_H_

client.h

#ifndef _CLIENT_H_
#define  _CLIENT_H_

#include <windows.h>
#include <process.h>
#include <stdio.h>
#include <conio.h>
#pragma comment(lib,"ws2_32.lib")
#define MAXBUF 126

/*
@function	InitSocket					   初始化套接字
@param		_Out_  SOCKET* ClientSocket	   client套接字
@param		_Out_ SOCKADDR_IN addrServer   server地址
@param	    _Out_ DWORD* dwError           错误代码
@param		_In_ unsigned long block       0为阻塞，非0为非阻塞
@return		BOOL						   成功返回TRUE 失败返回FALSE
*/
BOOL InitSocket(_Out_ SOCKET* ClientSocket, _Out_ SOCKADDR_IN addrServer, _Out_ DWORD* dwError, _In_ unsigned long block)
{
	BOOL bRet = FALSE;
	WSADATA wsaData = { 0 };
	do
	{
		if (!WSAStartup(MAKEWORD(2, 2), &wsaData))
		{
			if (LOBYTE(wsaData.wVersion) == 2 || HIBYTE(wsaData.wVersion) == 2)
			{
				*ClientSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
				if (ioctlsocket(*ClientSocket, FIONBIO, (unsigned long*)&block) != SOCKET_ERROR)
				{
					if (*ClientSocket != INVALID_SOCKET)
					{
						bRet = TRUE;
						break;
					}
					*dwError = WSAGetLastError();
				}
				*dwError = WSAGetLastError();
			}
		}
		*dwError = WSAGetLastError();
	} while (FALSE);
	return bRet;
}

/*
@function	ConnectServer				   连接服务器
@param		_Out_  SOCKET* ClientSocket	   client套接字
@param		_Out_ SOCKADDR_IN addrServer   server地址
@return		BOOL						   成功返回TRUE 失败返回FALSE
*/
BOOL ConnectServer(SOCKET* sClient, SOCKADDR_IN addrServer)
{
	DWORD dwError = 0;
	while (1)
	{
		if (SOCKET_ERROR == connect(*sClient, (SOCKADDR*)&addrServer, sizeof(addrServer)))
		{
			dwError = WSAGetLastError();
			if (dwError == WSAEWOULDBLOCK || dwError == WSAEINVAL)
			{
				Sleep(100);
				continue;
			}
			else if (dwError == WSAEISCONN)
				break;
			else
				return FALSE;
		}
		else
			break;
	}
	return TRUE;
}

/*
@function RecvData                  接收数据函数
@param  _In_ SOCKET s				套接字
@param  _Out_ char* buf				接收数据缓冲区
@param  _In_ int iSize				缓冲区大小
@return  返回接收到的数据大小
*/
int RecvData(SOCKET s, char* buf, int iSize)
{
	int iRemain = iSize;  //剩余字节
	int iCur = 0;         //当前读取到的字节
	int iLen = 0;
	while (iRemain)
	{
		iLen = recv(s, &buf[iCur], iSize, 0);
		if (iLen == SOCKET_ERROR)
			break;
		iCur += iLen;
		iRemain = iSize - iLen;  //求出还剩余多少字节没有读完
	}
	return iCur;
}

/*
@function RecvData                  发送数据函数
@param  _In_ SOCKET s				套接字
@param  _In_ char* buf				发送的数据
@param  _In_ int iSize				数据大小
@return  返回接收到的数据大小
*/
int SendData(SOCKET s, char* buf, int iSize)
{
	int iRemain = iSize;  //剩余字节
	int iCur = 0;         //当前发送的字节
	int iLen = 0;
	while (iRemain)
	{
		iLen = send(s, &buf[iCur], iSize, 0);
		if (iLen == SOCKET_ERROR)
		{
			DWORD dwError = GetLastError();
			if (dwError == WSAEWOULDBLOCK)
				continue;
			else                  //其它错误
				return -1;
		}
		iCur += iLen;
		iRemain = iSize - iLen;  //求出还剩余多少字节没有发送
	}
	return iCur;
}

//接收数据线程
unsigned int __stdcall ThreadRecv(void* lparam)
{
	char buf[MAXBUF] = { 0 };
	int iRet = 0;
	while (1)
	{
		Sleep(100);
		memset(buf, 0, MAXBUF);
		iRet = RecvData(*(SOCKET*)lparam, buf, MAXBUF);
		if (iRet == 0)
			continue;
		printf("Recv:%s\n", buf);
	}
	return 0;
}

//发送数据线程
unsigned int __stdcall ThreadSend(void* lparam)
{
	char buf[MAXBUF] = { 0 };
	while (1)
	{
		int c = getch();
		if (c == 72 || c == 0 || c == 68)//为了显示美观，加一个无回显的读取字符函数
			continue;
		memset(buf, 0, MAXBUF);
		printf("Send:");
		gets_s(buf);
		if (strlen(buf) == 0)
			continue;
		SendData(*(SOCKET*)lparam, buf, strlen(buf) + 1);
		Sleep(100);
	}
	return 0;
}

//显示信息
void ShowMessage(SOCKADDR_IN* addr)
{
	printf("Success connect server IP: %s,port: %d\n", inet_ntoa(addr->sin_addr), htons(addr->sin_port));
}



#endif //_CLIENT_H_
_acme_
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
java解读NIOSocket非阻塞模式.zip
09-02
jdk供的无阻塞I/O（NIO）有效解决了多线程服务器存在的线程开销问题，但在使用上略显得复杂一些。在NIO中使用多线程，主要目的已不是为了应对每个客户端请求而分配独立的服务线程，而是通过多线程充分使用用多个CPU的处理能力和处理中的等待时间，达到提高服务能力的目的。 client多线程请求server端，server接收client的名字，并返回Hello!＋名字的字符格式给client。当然实际应用并不这么简单，实际可能是访问文件或者数据库获取信息返回给client。非阻塞的NIO有何神秘之处？直接上代码！
非阻塞socket网络编程之数据收发完整代码示例
weixin_46935110的博客
12-09 3377
非阻塞socket网络编程之数据收发完整代码示例
feizuse.rar_C socket 非阻塞_网络服务_非阻塞_非阻塞 socket
09-19
此源码基于socket windows下网络服务器程序，非阻塞模式。
详解socket阻塞与非阻塞，同步与异步、I/O模型
01-01
socket阻塞与非阻塞，同步与异步 1. 概念理解 在进行网络编程时，我们常常见到同步(Sync)/异步(Async)，阻塞(Block)/非阻塞(Unblock)四种调用方式： 同步/异步主要针对C端: 同步： 所谓同步，就是在c端发出一个功能调用时，在没有得到结果之前，该调用就不返回。也就是必须一件一件事做,等前一件做完了才能做下一件事。 例如普通B/S模式（同步）：提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事 异步： 异步的概念和同步相对。当c端一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调
Linux UDP socket 设置为的非阻塞模式与阻塞模式区别
09-15
主要介绍了Linux UDP socket 设置为的非阻塞模式与阻塞模式区别的相关资料,需要的朋友可以参考下
socket阻塞和非阻塞模式
weixin_51281362的博客
06-26 6030
socket阻塞阻塞和非阻塞模式
JAVA系列 —— 阻塞非阻塞 同步异步 IO模型及其应用 NIO实现原理
JasonChen3318的博客
09-02 1112
一、NIO的与IO的区别： 1、IO是面向流的，NIO是面向缓冲的； 2、IO是阻塞的，NIO是非阻塞的； 3、IO是单线程的，NIO 是通过选择器来模拟多线程的； 1. 通道 通道 Channel 是对原 I/O 包中的流的模拟，可以通过它读取和写入数据。 通道与流的不同之处在于，流只能在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)，而...
socket 的阻塞模式和非阻塞模式
qq_41854911的博客
04-01 4279
在应用程序 A 与 应用程序 B 建立了 TCP 连接之后，假设应用程序 A 不断调用 send 函数，这样数据会不断拷贝至对应的内核缓冲区中，如果 B 那一端一直不调用 recv 函数，那么 B 的内核缓冲区被填满以后，A 的内核缓冲区也会被填满，此时 A 继续调用 send 函数会是什么结果呢？上面的示例验证了如果一端一直发数据，而对端应用层一直不取数据（或收取数据的速度慢于发送速度），则很快两端的内核缓冲区很快就会被填满，导致发送端调用 send 函数被阻塞。
非阻塞socket编程
罗布泊coding
03-30 4666
一. 阻塞与非阻塞阻塞： 阻塞调用是指调用结果返回之前，当前线程会被挂起。该进程被标记为睡眠状态并被调度出去。函数只有在得到结果之后才会返回。当socket工作在阻塞模式的时候， 如果没有数据的情况下调用该函数，则当前线程就会被挂起，直到有数据为止。 非阻塞： 非阻塞和阻塞的概念相对应，指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回。epoll工作在非阻塞模式时，才会发挥作用。二
socket阻塞和非阻塞有哪些影响
热门推荐
mayue_web的博客
09-27 3万+
socket阻塞和非阻塞有哪些不同
socket 多线程 例程 非阻塞模式
05-13
vc++6.0 编写socket多线程例程，非阻塞模式，客户端 服务器端源代码，可运行
python3 循环_事件循环 — Python 3.9.1rc1 文档
weixin_39586825的博客
12-03 403
事件循环¶前言事件循环是每个 asyncio 应用的核心。 事件循环会运行异步任务和回调，执行网络 IO 操作，以及运行子进程。应用开发者通常应当使用高层级的 asyncio 函数，例如 asyncio.run()，应当很少有必要引用循环对象或调用其方法。 本节所针对的主要是低层级代码、库和框架的编写者，他们需要更细致地控制事件循环行为。获取事件循环以下低层级函数可被用于获取、设置或创建事件循环:...
Socket的阻塞模式和非阻塞模式
游侠之魂的专栏
05-04 5210
阻塞模式 　　Windows套接字在阻塞和非阻塞两种模式下执行I/O操作。在阻塞模式下，在I/O操作完成前，执行的操作函数一直等候而不会立即返回，该函数所在的线程会阻塞在这里。相反，在非阻塞模式下，套接字函数会立即返回，而不管I/O是否完成，该函数所在的线程会继续运行。
Socket的非阻塞模式
weixin_46355954的博客
03-21 1916
socket的阻塞与非阻塞工作模式 设置socket非阻塞的方法 非阻塞socket编程
网络编程：socket的阻塞模式和非阻塞模式
Sauron7i的博客
08-28 9929
返回值n返回值含义大于0成功发送（send）或接收（recv）n字节0对端关闭连接小于0（-1）出错、信号被中断、对端TCP窗口太小导致数据发送不出去或当前网卡缓冲区已无数据可接收返回值大于0。在这种情形下，一定要判断send函数的返回值是不是我们期望发送的字节数，而不是简单的判断其返回值大于0.\n");}虽然返回值n大于0，但在实际情况下，由于对端的TCP可能因为缺少一部分字节就满了，所以n的值可能为(0, buf_length]。...
socket的非阻塞模式
xiachuyu的博客
08-17 941
参考使用了socket非阻塞模式，调用成功。这个是找到的链接资料。有空再把自己总结的上传一下。 非阻塞IO 和阻塞IO： 在网络编程中对于一个网络句柄会遇到阻塞IO 和非阻塞IO 的概念, 这里对于这两种socket 先做一下说明： 基本概念： 阻塞IO:: socket 的阻塞模式意味着必须要做完IO 操作（包括错误）才会 返回。 非阻塞IO::
socket实现非阻塞网络通信实现
貌似稿手的博客
03-17 1035
一、select函数 select() 可以阻塞地同时探测一组支持非阻塞的 I / O 设备是否有事件发生（如可读，可写，出现异常等等），直至某一个设备触发了事件或者超过了指定的等待时间。此时我们可以把需要的数据源通道放到 select 的探测范围内，只要相应的数据源准备好 select 就会返回，这时就能无阻塞地读取到数据。 select()函数原型及介绍如下所示 int select(int nfds, fd_set* readfds, fd_set* writefds, fd_set* erro
非阻塞式socket
一个菜鸟的博客
04-14 1万+
引言 返回错误EWOULDBLOCK或EAGAIN。 套接字的默认状态是阻塞的。这就意味着当发出一个不能立即完成的套接字调用时，其进 程将被投入睡眠，等待相应操作完成。可能阻塞的套接字调用可分为以下四类： ( 1 ) 输入操作，包括read 、 readv、 recv、 recvfrom和 recvmsg共5个函数。如果某个进程对一个阻塞的TCP套接字（默认设置）调用这些输入函数之，而且该...
linux简单C++服务器基于TCP协议
08-09 716
在入口点创建,绑定,监听socket,并接受客户端连接。
java Socket非阻塞模式
最新发布
05-24
Java的Socket类可以通过设置非阻塞模式来实现非阻塞的网络通信。在非阻塞模式下，当没有数据可读时，read()方法会立即返回0，而不是一直等待数据到达；当发送缓冲区已满时，write()方法会立即返回0，而不是一直等待缓冲区可用。 具体实现方式如下： 1. 创建Socket对象并连接到服务器 ```java Socket socket = new Socket("hostname", port); ``` 2. 将Socket对象设置为非阻塞模式 ```java socket.setSoTimeout(0); // 设置读取超时时间为0，即无限等待 socket.getChannel().configureBlocking(false); // 设置非阻塞模式 ``` 3. 进行读写操作 ```java // 读取数据 ByteBuffer buffer = ByteBuffer.allocate(1024); socket.getChannel().read(buffer); // 写入数据 String message = "Hello, Server!"; ByteBuffer buffer = ByteBuffer.wrap(message.getBytes()); socket.getChannel().write(buffer); ``` 需要注意的是，在非阻塞模式下，由于读写操作是异步的，我们需要不断地调用read()和write()方法来检查是否有数据可读或缓冲区可用。可以使用Java NIO库中的Selector类来实现这一点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值