网络：异步事件模型

于 2022-09-05 13:25:02 发布
阅读量102 收藏
点赞数
分类专栏： 网络 文章标签： 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69414302/article/details/126703294
版权

相较于同步非阻塞模型

异步事件模型的特点:

效率要更高:由于异步通知

单线程处理多个套接字

异步事件模型:

向windows注册  当事件发生 将事件置为有信号

  步骤如下

1. 初始化网络

2.注册事件 :Eventselect(socket,fd_accept,事件)

3.创建处理事件的线程

while(1)

{
等多个事件信号  waitmulevents();

判断发生什么事件了

socket sockWaiter =accept();

向Windows注册(sockWaiter,fd_read,事件2);

}


完整代码如下

类声明：

#ifndef CTCPMAP_H
#define CTCPMAP_H
 
#include<list>
#include<winsock2.h>
#include<windows.h>
#include<iostream>
#include<map>
using namespace std;
#define MaxNum 64
struct DataInfo
{
    char* pszbuf;
    int  nPacksize;
    int  noffest;
};
 
class CTCPmap
{
public:
    //构造
    CTCPmap();
    //析构
    ~CTCPmap();
    //初始化网络
    bool InitnewWork();
    //销毁网络
    void DeleteWork();
    //线程函数
    static DWORD WINAPI ThreadEventSelect(LPVOID lpvoid);
 
    static DWORD WINAPI ThreadSelect(LPVOID lpvoid);
    static DWORD WINAPI ThreadAccept(LPVOID lpvoid);
    static DWORD WINAPI ThreadRecv(LPVOID lpvoid);
    //发送数据
    bool sendDate(SOCKET sockWaiter,char*szbuf,int nLen);
    //接收数据
    void recvDate();
 
private:
    //监听者句柄
    SOCKET m_soclisten;
    //总线程池
    std::list<HANDLE> my_Threadpool;
    //服务者线程池
    std::list<SOCKET> my_ThreadWaiter;
    //线程结束标识
    bool my_FlagQuit;
    //传服务者sockWaiter用到的容器
    std::map<DWORD,SOCKET> my_map;
    //结构体与套接字的映射
    std::map<SOCKET,DataInfo*> m_sdmap;
    fd_set m_fd;
    SOCKET m_arySocket[MaxNum];
    HANDLE m_aryEvent[MaxNum];
    int  m_nEventNum;
 
 
};
 
#endif // CTCPMAP_H


实现：

#include "ctcpmap.h"
 
CTCPmap::CTCPmap()
{
 
    m_soclisten=0;
    my_FlagQuit=true;
    FD_ZERO(&m_fd);
    m_nEventNum=0;
    ZeroMemory(m_arySocket,sizeof(m_arySocket));
    ZeroMemory(m_aryEvent,sizeof(m_aryEvent));
 
}
CTCPmap::~CTCPmap()
{
 
}
 
bool CTCPmap::InitnewWork()
{
 
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;
 
 
    wVersionRequested = MAKEWORD(2, 2);
 
    err = WSAStartup(wVersionRequested, &wsaData);
    if (err != 0) {
 
 
        DeleteWork();
        return false;
    }
 
 
 
    if (LOBYTE(wsaData.wVersion) != 2 || HIBYTE(wsaData.wVersion) != 2) {
 
        WSACleanup();
        return false;
    }
 
 
 
 
//创建套接字
    m_soclisten=socket(AF_INET,SOCK_STREAM,0);
    if(m_soclisten==INVALID_SOCKET)
    {
       DeleteWork();
        return false;
    }
//绑定
    sockaddr_in addrserver;
    //绑定IP
    addrserver.sin_addr.S_un.S_addr=0;
    addrserver.sin_port=htons(8899);
    addrserver.sin_family=AF_INET;
    if(SOCKET_ERROR==bind(m_soclisten,(sockaddr*)&addrserver,sizeof(addrserver)))
    {
          DeleteWork();
            return false;
 
    }
 
 
 
//监听
 
    if(SOCKET_ERROR==listen(m_soclisten,10))
 
    {
        DeleteWork();
        return false;
 
    }
 
    HANDLE hevent=WSACreateEvent();
 
    if(!WSAEventSelect(m_soclisten,hevent,FD_ACCEPT))
    {
        m_arySocket[m_nEventNum]=m_soclisten;
        m_aryEvent[m_nEventNum]=hevent;
        m_nEventNum++;
    }
 
    HANDLE hand=CreateThread(0,0,&ThreadEventSelect,this,0,0);
    if(hand)
       my_Threadpool.push_back(hand);
 
//    //将套接字加入到集合
//    FD_SET(m_soclisten,&m_fd);
//    //创建线程
//    HANDLE hand=CreateThread(0,0,&ThreadSelect,this,0,0);
//    if(hand)
//       my_Threadpool.push_back(hand);
//    HANDLE hand=CreateThread(0,0,&ThreadAccept,this,0,0);
//    if(hand)
//        my_Threadpool.push_back(hand);
//    hand=CreateThread(0,0,&ThreadRecv,this,0,0);
//    //创建服务者线程 加入到线程池
//    if(hand)
//        my_Threadpool.push_back(hand);
 
    return  true;
 
 
}
 
void CTCPmap::DeleteWork()
{
    //线程销毁
    my_FlagQuit=false;
    auto ite=my_Threadpool.begin();
    while(ite!=my_Threadpool.end())
    {
        if(WAIT_TIMEOUT==WaitForSingleObject(*ite,100))
            TerminateThread(*ite,-1);
        CloseHandle(*ite);
        *ite=NULL;
        ite++;
    }
 
    my_Threadpool.clear();
     //关闭句柄
    if(m_soclisten)
        {
        closesocket(m_soclisten);
        m_soclisten=0;
    }
 
    //卸载服务器
    WSACleanup();
}
 
DWORD WINAPI CTCPmap::ThreadEventSelect(LPVOID lpvoid)
{
    CTCPmap *pthis=(CTCPmap*)lpvoid;
    DWORD dwIndex;
    WSANETWORKEVENTS we;
    sockaddr_in addrclient;
    int  nsize=sizeof(addrclient);
    int  nRecvNum;
    while(pthis->my_FlagQuit)
    {
        //等事件
        dwIndex=WSAWaitForMultipleEvents(pthis->m_nEventNum,pthis->m_aryEvent,FALSE,WSA_INFINITE,0);
        dwIndex-=WSA_WAIT_EVENT_0;
        //判断发生什么事
        if(SOCKET_ERROR==WSAEnumNetworkEvents(pthis->m_arySocket[dwIndex],
                                               pthis->m_aryEvent[dwIndex],
                                               &we))
            continue;
        //处理
        if(we.lNetworkEvents&FD_ACCEPT)
        {
            cout<<"等待客户端连接"<<endl;
            SOCKET sockWaiter=accept(pthis->m_soclisten,(sockaddr*)&addrclient,&nsize);
 
            cout<<"client ip:"<<inet_ntoa(addrclient.sin_addr)<<"accept"<<endl;
 
            //对应失败  跳出 继续循环
            if(sockWaiter==INVALID_SOCKET)continue;
            HANDLE hevent=WSACreateEvent();//人工的无信号事件
 
            if(!WSAEventSelect(sockWaiter,hevent,FD_READ|FD_CLOSE))
            {
                pthis->m_arySocket[pthis->m_nEventNum]=sockWaiter;
                pthis->m_aryEvent[pthis->m_nEventNum]=hevent;
                pthis->m_nEventNum++;
            }
 
 
        }
 
        if(we.lNetworkEvents&FD_READ)
            {
                DataInfo *pData=pthis->m_sdmap[pthis->m_arySocket[dwIndex]];
                //代表waiter 有数据来了
                if(!pData)
                {
                    pData=new DataInfo;
                    pData->noffest=0;
                    pData->nPacksize=0;
                    pthis->m_sdmap[pthis->m_arySocket[dwIndex]]=pData;
                    //waiter come
                    nRecvNum=recv(pthis->m_arySocket[dwIndex],(char*)&pData->nPacksize,sizeof(int),0);
                    if(pData->nPacksize>0)
                    {
                        pData->pszbuf=new char[pData->nPacksize];
                    }
                }
                else
                {
                    nRecvNum=recv(pthis->m_arySocket[dwIndex],pData->pszbuf+pData->noffest,pData->nPacksize,0);
                    if(nRecvNum>0)
 
                    {
                        pData->noffest+=nRecvNum;
                        pData->nPacksize-=nRecvNum;
                        if(pData->nPacksize==0)
                        {
                            //数据包接受完整
                            cout<<pData->pszbuf<<endl;
                            delete []pData->pszbuf;
                            pData->pszbuf=NULL;
 
                            delete [] pData;
                            pData=NULL;
                            pthis->m_sdmap[pthis->m_arySocket[dwIndex]]=NULL;
 
                        }
                    }
             }
 
             }
 
        if(we.lNetworkEvents&FD_CLOSE)
            {
                closesocket(pthis->m_arySocket[dwIndex]);
                WSACloseEvent(pthis->m_aryEvent[dwIndex]);
                if(pthis->m_nEventNum>1)
                {
                    pthis->m_arySocket[dwIndex]=pthis->m_arySocket[pthis->m_nEventNum-1];
                    pthis->m_aryEvent[dwIndex]=pthis->m_aryEvent[pthis->m_nEventNum-1];
 
 
 
                }
                pthis->m_nEventNum--;
            }
 
 
 
    }
    return  0;
}
//将集合交给select线程函数
DWORD WINAPI CTCPmap::ThreadSelect(LPVOID lpvoid)
{
    CTCPmap *pthis=(CTCPmap*)lpvoid;
    fd_set fdtemp;
    TIMEVAL tv;
    tv.tv_sec=0;
    tv.tv_usec=100;
    sockaddr_in addrclient;
 
    int  nRecvNum;
    int  nsize=sizeof(addrclient);
    while(pthis->my_FlagQuit)
        {
 
        fdtemp =pthis->m_fd;
        //将套接字交给集合
         select(0,&fdtemp,0,0,&tv);
        if(FD_ISSET(pthis->m_soclisten,&fdtemp))
        {
            //代表有人连接我了
            SOCKET sockWaiter=accept(pthis->m_soclisten,(sockaddr*)&addrclient,&nsize);
 
            cout<<"client ip:"<<inet_ntoa(addrclient.sin_addr)<<"accept"<<endl;
 
            //对应失败  跳出 继续循环
            if(sockWaiter==INVALID_SOCKET)continue;
            //将waiter加入到集合内
            FD_SET(sockWaiter,&pthis->m_fd);
        }
 
        //校验
        for(unsigned int i=1;i<pthis->m_fd.fd_count;i++)
        {
 
 
            if(FD_ISSET(pthis->m_fd.fd_array[i],&fdtemp))
            {
                DataInfo *pData=pthis->m_sdmap[pthis->m_fd.fd_array[i]];
                //代表waiter 有数据来了
                if(!pData)
                {
                    pData=new DataInfo;
                    pData->noffest=0;
                    pData->nPacksize=0;
                    pthis->m_sdmap[pthis->m_fd.fd_array[i]]=pData;
                    //waiter come
                    nRecvNum=recv(pthis->m_fd.fd_array[i],(char*)&pData->nPacksize,sizeof(int),0);
                    if(pData->nPacksize>0)
                    {
                        pData->pszbuf=new char[pData->nPacksize];
                    }
                }
                else
                {
                    nRecvNum=recv(pthis->m_fd.fd_array[i],pData->pszbuf+pData->noffest,pData->nPacksize,0);
                    if(nRecvNum>0)
 
                    {
                        pData->noffest+=nRecvNum;
                        pData->nPacksize-=nRecvNum;
                        if(pData->nPacksize==0)
                        {
                            //数据包接受完整
                            cout<<pData->pszbuf<<endl;
                            delete []pData->pszbuf;
                            pData->pszbuf=NULL;
 
                            delete [] pData;
                            pData=NULL;
                            pthis->m_sdmap[pthis->m_fd.fd_array[i]]=NULL;
 
                        }
                    }
                }
 
 
            }
 
        }
 
}
 
     return  0;
 
}
 
//接收客户端的线程函数
 DWORD WINAPI CTCPmap::ThreadAccept(LPVOID lpvoid)
 {
     CTCPmap *pthis=(CTCPmap*)lpvoid;
 
     sockaddr_in addrclient;
     int  nsize=sizeof(addrclient);
 
     u_long iMode=1;
     while(pthis->my_FlagQuit)
     {
         //店长接受客人 分配给服务员  --接受链接--accept();
 
         //服务者与他的客人对应起来
             SOCKET sockWaiter=accept(pthis->m_soclisten,(sockaddr*)&addrclient,&nsize);
 
             cout<<"client ip:"<<inet_ntoa(addrclient.sin_addr)<<"accept"<<endl;
 
             //对应失败  跳出 继续循环
             if(sockWaiter==INVALID_SOCKET)continue;
             //对应成功 线程池添加了一个服务者线程
 
             //将Waiter 介入到链表 将waiter设置为非阻塞
 
             ioctlsocket(sockWaiter,FIONBIO,&iMode);
 
             //将服务者套接字加入到集合
             //FD_SET(sockWaiter,&(pthis->m_fd));
 
             pthis->my_ThreadWaiter.push_back(sockWaiter);
 
 
 
 
 
 
     }
     return  0;
 
 
 }
 
DWORD WINAPI CTCPmap::ThreadRecv(LPVOID lpvoid)
{
    CTCPmap *pthis=(CTCPmap*)lpvoid;
 
    while(pthis->my_FlagQuit)
    {
        // 接受
        pthis->recvDate();
        Sleep(10);
 
    }
    return  0;
 
}
 
void CTCPmap::recvDate()//接收函数
{
 
            // 服务员等客人说话 --recv();
                char *pszbuf=NULL;
                //当前位置标识
                int offset=0;
                //包长度
                int  nPackSize;
 
                int  nRecvNum;
                SOCKET sockWaiter;
 
 
 
                auto ite=my_ThreadWaiter.begin();
                while(ite!=my_ThreadWaiter.end())
                {
                    sockWaiter=*ite;
 
                        //jieshoubaodaxiao
                        nRecvNum=recv(sockWaiter,(char*)&nPackSize,sizeof(int ),0);
                        if(nRecvNum<=0)
                        {
                            //判断服务器是否下线
                            if(WSAGetLastError()==10054)
                            {
                                //删除映射
                                auto ite=my_map.begin();
                                while(ite!=my_map.end())
                                {
                                    if(ite->second==sockWaiter)
                                    {
                                        my_map.erase(ite);
                                        closesocket(sockWaiter);
                                        break;
                                    }
                                    //ite++;
                                }
 
                                break;
                            }
                            continue;
                            ite++;
                        }
                        //获得接受内容
                        pszbuf=new char[nPackSize];
                        while(nPackSize)//看当前剩余的还有多少没接受完
                        {
                            nRecvNum=recv(sockWaiter,pszbuf+offset,nPackSize,0);
                            if(nRecvNum>0)
                            {
                                nPackSize-=nRecvNum;
                                offset+=nRecvNum;
                            }
                        }
                        cout<<"client say:"<<pszbuf<<endl;
                        sendDate(sockWaiter,pszbuf,  nRecvNum);
                        delete []pszbuf;
                        pszbuf=NULL;
 
 
 
 
 
                     ite++;
                }
 
 
 
 
}
 
 
bool CTCPmap:: sendDate(SOCKET sockWaiter,char*szbuf,int  nLen)
{
 
 
    if(sockWaiter==INVALID_SOCKET||!szbuf||nLen<=0)
        return  false;
    if(send(sockWaiter,(char*)&nLen,sizeof(int ),0)<=0)
     return  false;
    if(send(sockWaiter,szbuf,nLen,0)<=0)
     return  false;
 
    int  nRecvNum;
    int nRecvNuumSIze=sizeof(szbuf);
 
    while(my_FlagQuit)
    {
        cin>>szbuf;
 
        send(sockWaiter,(char*)&nRecvNuumSIze,sizeof(int),0);
        send(sockWaiter,szbuf,sizeof(szbuf),0);
 
        //recv()
        nRecvNum= recv(sockWaiter,szbuf,sizeof(szbuf),0);
        if(sockWaiter>0)
        {
            cout<<"fuwuqi say:"<<szbuf<<endl;
        }
 
 
 
    }
 
   return true;
 
}

主函数：

#include <QCoreApplication>
#include<winsock2.h>
#include<iostream>
#include"ctcpmap.h"
using namespace std;
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    /*
     *1.选择种类  --WSAStartup();
     *2.雇店长  --创建套接字 socket();
     *3.找地 --绑定 --bind();
     *4.店长宣传 --监听 --listen();
     *5.店长接受客人 分配给服务员  --接受链接--accept();
     *6.客人与服务员 服务员等客人说话 --recv();
     *7.回复 --send();
     *8.下班--closesocket();
     *9.关门--WASCleanup();
     *
     */
 
    CTCPmap ctcp;
    if(ctcp.InitnewWork())
        cout<<"initnework sucess"<<endl;
 
 
 
 
 
 
 
    return a.exec();
}

@布响丸辣
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Socket编程模型之完成端口模型
cheqiane9431的博客
08-14 403
转载请注明来源：http://blog.csdn.net/caoshiying?viewmode=contents 一、回顾重叠IO模型 用完成例程来实现重叠I/O比用事件通知简单得多。在这个模型中，主线程只用不停的接受连接即可；辅助线程判断有没有新的客户端连接被建立，如果有，...
计算机网络 完成端口模型
van9527的博客
08-26 194
计算机网络 完成端口模型
SOCKET编程登峰造极之完成端口
weixin_33851177的博客
11-22 123
一、什么是完成端口？完成端口---是一种WINDOWS内核对象。完成端口用于异步方式的重叠I/0情况下，当然重叠I/O不一定非使用完成端口不可，还有设备内核对象、事件对象、告警I/0等。但是完成端口内部提供了线程池的管理，可以避免反复创建线程的开销，同时可以根据CPU的个数灵活的决定线程个数，而且可以让减少线程调度的次数从而提高性能。二、完成端口的内部机制 1）创建完成端口完成端口是一个内核对...
使用IOCP完成端口和SOCKET封装的成熟异步TCP类
01-18
使用IOCP完成端口和SOCKET封装的异步TCP类。 支持客户端和服务器的常用TCP接口：绑定Bind、监听Listen、接收Recv、连接Conn、发送Send、关闭Close。所有接口均使用异步回调的方式处理，内部实现使用Windows下性能最高的IOCP完成端口网络模型，并很好地处理了多线程安全和同步问题。 线程创建和事件信号量等地方用到了MFC的类，如果项目不支持MFC，可以把这些地方替换成WindowsAPI的方式。 代码是从成熟项目中分离出来的，能达到很高的性能和网络吞吐量，并且稳定无BUG。
Win socket编程--IOCP完成端口模型
zzhongcy的专栏
08-18 4052
一、为什么选用完成端口 网络通信方式大致有以下几种： 同步方式：所有操作在一个线程内顺序执行，则通信操作会阻塞同一线程其他操作。同步+多线程方式：服务器端为每一个连入的客户端建立一个线程进行通信，但当客户端过多时，建立大量线程占用过多资源，而且CPU需要很多时间进行线程的切换。完成端口：让所有的通信请求排到队列中，利用事先建立的少量几个线程依次处理队列中的请求，因为线程数量少，无需用大
Servya:异步 .NETMono 网络服务器
07-02
特征一路异步支持事件驱动 (Node.js) 和 thread-per-request (Apache) 模式没有回调地狱！ 内置依赖注入（无需配置） 简单的服务模型：只需使用类和方法来建模您的 API你好，世界[ Service ]class ProgramService{//...
yohub:C++轻量级异步事件驱动网络应用框架
07-01
异步模型。 异步编程模型是由灵感，yohub只通知客户端I / O操作完成后。 由于事件循环与工作池分离，yohub 选择边缘触发的就绪通知模型。 尽管如此，边缘触发的就绪通知使实时响应成为可能，并且与工作池配合时使...
基于TCP异步Socket模型的介绍
09-05
基于TCP的异步Socket模型是网络编程中一种高效且非阻塞的通信方式，它主要用于构建高并发、高性能的服务器应用程序。在这个模型中，服务器并不会因为等待客户端的响应而阻塞，而是通过异步调用来处理连接、发送和...
异步事件驱动的物联网服务模型1
08-03
为解决这一问题，本文提出了一个基于异步事件驱动的高性能网络服务模型。 【标签】：物联网, 异步通信, 事件驱动, 网络服务 【正文】： 物联网(IoT)的广泛应用推动了网络服务的需求急剧增加，服务提供商必须能够...
TCP/IP WsaAsyncSelect异步选择模型
04-10
TCP/IP WsaAsyncSelect异步选择模型
把socket IOCP完成端口网络通信模型封装成c++类.zip
03-30
把socket IOCP网络通信模型封装成c++类.zip
完成端口（IOCP）模型示例
12-15
windows完成端口（IOCP）模型示例代码，含客户端和服务端代码。
socket编程--完成端口模型
weixin_33770878的博客
04-28 195
目录： 一、为什么选用完成端口 二、完成端口的概念 三、完成端口的基本流程 四、实现详解—主线程 五、实现详解—工作者线程 一、为什么选用完成端口 网络通信方式大致有以下几种： 同步方式：所有操作在一个线程内顺序执行，则通信操作会阻塞同一线程其他操作。 同步+多线程方式：服务器端为每一个连入的客户端建立一个线程进行通信，但当客户端过多时，建立大量线程占用过多资源，而且C...
完成端口模型的理解
qq_41985652的博客
03-21 2389
完成端口的优点 1. 我想只要是写过或者想要写C/S模式网络服务器端的朋友，都应该或多或少的听过完成端口的大名吧，完成端口会充分利用Windows内核来进行I/O的调度，是用于C/S通信模式中性能最好的网络通信模型，没有之一；甚至连和它性能接近的通信模型都没有。 2. 完成端口和其他网络通信方式最大的区别在哪里呢？ (1) 首先，如果使用“同步...
网络IO模型之异步事件模型
weixin_45178126的博客
04-06 495
异步事件模型： 像操作系统注册信息（socket、网络事件、事件），当指定网络时间按发生，将事件置为信号。 特点：被动通知 个数限制 64 （多线程 多数组） 性能较优 阻塞：自己拷贝数据 如果有两个事件发生信号，只会发生索引最小的那个。 #include "ctcpnet.h" #include <winsock2.h> #include <windows.h> //winsock.h #include <iostream> #include <QDebug&.
异步编程和事件模型
robert198837的专栏
08-22 1700
网络编程其实很大一部分的内容就是处理各种IO，对IO模型的理解，能使我们对UB模型机制更深一层的理解。特别是下面会说到的异步编程和事件模型。 1. 同步阻塞IO 同步阻塞IO模型如下图。 Read，write这些操作，其实都是应用程序通过内核的系统调用完成的。为了执行read操作，应用程序会调用相应的一个系统调用（system call），此时系统控制权就交给内核，应用程
关于windows完成端口（IOCP）的一些理解
热门推荐
左雪菲的专栏
07-06 1万+
       本人很多年前接触完成端口以来，期间学习和练习了很多次，本以为自己真正地理解了其原理，最近在看网狐的服务器端源码时又再一次拾起完成端口的知识，结果发现以前理解的其实很多偏差，有些理解的甚至都是错误的。网络上关于windows完成端口的介绍举不胜举，但大多数都是介绍怎么做，而不是为告诉读者为什么这么做。看了很多遍小猪的讲解：http://blog.csdn.net/piggyxp/art...
网络编程(c++)课程设计飞鸽传书udp异步消息模型
最新发布
01-29
飞鸽传书是一种基于UDP异步消息模型的网络编程课程设计。UDP是一种无连接的传输层协议，它比TCP更轻量级，传输速度更快，适合于快速传递小量数据的场景，而异步消息模型则能够提高系统的并发处理能力。 在这个课程...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值