select模型][][WSAEventSelect模型]基于Delphi的Socket I/O模型全接触

最新推荐文章于 2019-08-30 13:54:43 发布
最新推荐文章于 2019-08-30 13:54:43 发布
阅读量1.4k 收藏 8
点赞数
文章标签： socket delphi integer 远程连接 微软 microsoft

老陈有一个在外地工作的女儿，不能经常回来，老陈和她通过信件联系。他们的信会被邮递员投递到他们的信箱里。

　　这和Socket模型非常类似。下面我就以老陈接收信件为例讲解Socket I/O模型。

　　一：select模型

　　老陈非常想看到女儿的信。以至于他每隔10分钟就下楼检查信箱，看是否有女儿的信，在这种情况下，“下楼检查信箱”然后回到楼上耽误了老陈太多的时间，以至于老陈无法做其他工作。

　　select模型和老陈的这种情况非常相似：周而复始地去检查......如果有数据......接收/发送.......

　　使用线程来select应该是通用的做法：

view plain print ?
  1. procedure  TListenThread . Execute;  
  2. var   
  3. 　addr  : TSockAddrIn;  
  4. 　fd_read : TFDSet;  
  5. 　timeout : TTimeVal;  
  6. 　ASock,  
  7. 　MainSock : TSocket;  
  8. 　len, i : Integer;  
  9. begin   
  10. 　MainSock := socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );  
  11. 　addr . sin_family := AF_INET;  
  12. 　addr . sin_port := htons( 5678 );  
  13. 　addr . sin_addr . S_addr := htonl(INADDR_ANY);  
  14. 　bind( MainSock, @addr , sizeof( addr ) );  
  15. 　listen( MainSock, 5  );  
  16.   
  17. 　while  ( not  Terminated)  do   
  18. 　begin   
  19. 　　FD_ZERO( fd_read );  
  20. 　　FD_SET( MainSock, fd_read );  
  21. 　　timeout. tv_sec :=  0 ;  
  22. 　　timeout. tv_usec :=  500 ;  
  23. 　　if  select(  0 , @fd_read,  nil ,  nil , @timeout ) >  0   then   //至少有1个等待Accept的connection   
  24. 　　begin   
  25. 　　　if  FD_ISSET( MainSock, fd_read )  then   
  26. 　　　begin   
  27. 　　　for  i:= 0   to  fd_read . fd_count- 1   do   //注意，fd_count <= 64，也就是说select只能同时管理最多64个连接   
  28. 　　　begin   
  29. 　　　　len := sizeof(addr );  
  30. 　　　　ASock := accept( MainSock, addr , len );  
  31. 　　　　if  ASock <> INVALID_SOCKET  then   
  32. 　　　　　....//为ASock创建一个新的线程，在新的线程中再不停地select   
  33. 　　　　end ;   
  34. 　　　end ; 　　  
  35. 　　end ;   
  36. 　end ;  //while (not self.Terminated)   
  37.   
  38. 　shutdown( MainSock, SD_BOTH );  
  39. 　closesocket( MainSock );  
  40. end ;   


　　二：WSAAsyncSelect模型

　　后来，老陈使用了微软公司的新式信箱。这种信箱非常先进，一旦信箱里有新的信件，盖茨就会给老陈打电话：喂，大爷，你有新的信件了！从此，老陈再也不必频繁上下楼检查信箱了，牙也不疼了，你瞅准了，蓝天......不是，微软......

　　微软提供的WSAAsyncSelect模型就是这个意思。

　　WSAAsyncSelect模型是Windows下最简单易用的一种Socket I/O模型。使用这种模型时，Windows会把网络事件以消息的形势通知应用程序。

　　首先定义一个消息标示常量：

view plain print ?
  1. const  WM_SOCKET = WM_USER +  55 ;   


　　再在主Form的private域添加一个处理此消息的函数声明：

view plain print ?
  1. private   
  2. procedure  WMSocket( var  Msg: TMessage); message WM_SOCKET;   
  3.   
  4. 　　//然后就可以使用WSAAsyncSelect了：   
  5.   
  6. var   
  7. 　addr  : TSockAddr;  
  8. 　sock : TSocket;  
  9.   
  10. 　sock := socket( AF_INET, SOCK_STREAM, IPPROTO_TCP );  
  11. 　addr . sin_family := AF_INET;  
  12. 　addr . sin_port := htons( 5678 );  
  13. 　addr . sin_addr . S_addr := htonl(INADDR_ANY);  
  14. 　bind( m_sock, @addr , sizeof(SOCKADDR) );  
  15.   
  16. 　WSAAsyncSelect( m_sock, Handle, WM_SOCKET, FD_ACCEPT or  FD_CLOSE );  
  17.   
  18. 　listen( m_sock, 5  );  
  19. 　....   
  20.   
  21. 　　//应用程序可以对收到WM_SOCKET消息进行分析，判断是哪一个socket产生了网络事件以及事件类型：   
  22.   
  23. procedure  TfmMain . WMSocket( var  Msg: TMessage);  
  24. var   
  25. 　sock : TSocket;  
  26. 　addr  : TSockAddrIn;  
  27. 　addrlen : Integer;  
  28. 　buf : Array [0..4095 ]  of  Char;  
  29. begin   
  30. 　//Msg的WParam是产生了网络事件的socket句柄，LParam则包含了事件类型   
  31. 　case  WSAGetSelectEvent( Msg . LParam )  of   
  32. 　FD_ACCEPT :  
  33. 　　begin   
  34. 　　　addrlen := sizeof(addr );  
  35. 　　　sock := accept( Msg. WParam,  addr , addrlen );  
  36. 　　　if  sock <> INVALID_SOCKET  then   
  37. 　　　　WSAAsyncSelect( sock, Handle, WM_SOCKET, FD_READ or  FD_WRITE  or  FD_CLOSE );  
  38. 　　end ;  
  39.   
  40. 　　FD_CLOSE : closesocket( Msg. WParam );  
  41. 　　FD_READ : recv( Msg. WParam, buf[ 0 ],  4096 ,  0  );  
  42. 　　FD_WRITE : ;  
  43. 　end ;   
  44. end ;   



三：WSAEventSelect模型

　 　后来，微软的信箱非常畅销，购买微软信箱的人以百万计数......以至于盖茨每天24小时给客户打电话，累得腰酸背痛，喝蚁力神都不好使。微软改进了 他们的信箱：在客户的家中添加一个附加装置，这个装置会监视客户的信箱，每当新的信件来临，此装置会发出“新信件到达”声，提醒老陈去收信。盖茨终于可以 睡觉了。

　　同样要使用线程：

view plain print ?
  1. procedure  TListenThread . Execute;  
  2. var   
  3. 　hEvent : WSAEvent;  
  4. 　ret : Integer;  
  5. 　ne : TWSANetworkEvents;  
  6. 　sock : TSocket;  
  7. 　adr : TSockAddrIn;  
  8. 　sMsg : String;  
  9. 　Index,  
  10. 　EventTotal : DWORD;  
  11. 　EventArray : Array [0.. WSA_MAXIMUM_WAIT_EVENTS- 1 ]  of  WSAEVENT;  
  12. begin   
  13. 　...socket... bind...  
  14. 　hEvent := WSACreateEvent();  
  15. 　WSAEventSelect( ListenSock, hEvent, FD_ACCEPT or  FD_CLOSE );  
  16. 　...listen...  
  17.   
  18. 　while  (  not  Terminated )  do   
  19. 　begin   
  20. 　　Index := WSAWaitForMultipleEvents( EventTotal, @EventArray[0 ], FALSE, WSA_INFINITE, FALSE );  
  21. 　　FillChar( ne, sizeof(ne), 0  );  
  22. 　　WSAEnumNetworkEvents( SockArray[Index-WSA_WAIT_EVENT_0], EventArray[Index-WSA_WAIT_EVENT_0], @ne );  
  23.   
  24. 　　if  ( ne . lNetworkEvents  and  FD_ACCEPT ) >  0   then   
  25. 　　begin   
  26. 　　　if  ne . iErrorCode[FD_ACCEPT_BIT] <>  0   then   
  27. 　　　　continue;  
  28.   
  29. 　　　ret := sizeof(adr);  
  30. 　　　sock := accept( SockArray[Index-WSA_WAIT_EVENT_0], adr, ret );  
  31. 　　　if  EventTotal > WSA_MAXIMUM_WAIT_EVENTS- 1   then //这里WSA_MAXIMUM_WAIT_EVENTS同样是64   
  32. 　　　begin   
  33. 　　　　closesocket( sock );  
  34. 　　　　continue;  
  35. 　　　end ;  
  36.   
  37. 　　　hEvent := WSACreateEvent();  
  38. 　　　WSAEventSelect( sock, hEvent, FD_READ or  FD_WRITE  or  FD_CLOSE );  
  39. 　　　SockArray[EventTotal] := sock;  
  40. 　　　EventArray[EventTotal] := hEvent;  
  41. 　　　Inc( EventTotal );  
  42. 　　end ;  
  43.   
  44. 　　if  ( ne . lNetworkEvents  and  FD_READ ) >  0   then   
  45. 　　begin   
  46. 　　　if  ne . iErrorCode[FD_READ_BIT] <>  0   then   
  47. 　　　　continue;  
  48. 　　　　FillChar( RecvBuf[0 ], PACK_SIZE_RECEIVE,  0  );  
  49. 　　　　ret := recv( SockArray[Index-WSA_WAIT_EVENT_0], RecvBuf[0 ], PACK_SIZE_RECEIVE,  0  );  
  50. 　　　　......  
  51. 　　　end ;  
  52. 　　end ;  
  53. end ;   


　　四：Overlapped I/O 事件通知模型

　 　后来，微软通过调查发现，老陈不喜欢上下楼收发信件，因为上下楼其实很浪费时间。于是微软再次改进他们的信箱。新式的信箱采用了更为先进的技术，只要用 户告诉微软自己的家在几楼几号，新式信箱会把信件直接传送到用户的家中，然后告诉用户，你的信件已经放到你的家中了！老陈很高兴，因为他不必再亲自收发信 件了！

　　Overlapped I/O 事件通知模型和WSAEventSelect模型在实现上非常相似，主要区别在“Overlapped”，Overlapped模型是让应用程序使用重叠 数据结构(WSAOVERLAPPED)，一次投递一个或多个Winsock I/O请求。这些提交的请求完成后，应用程序会收到通知。什么意思呢？就是说，如果你想从socket上接收数据，只需要告诉系统，由系统为你接收数据， 而你需要做的只是为系统提供一个缓冲区~~~~~
Listen线程和WSAEventSelect模型一模一样，Recv/Send线程则完全不同：

view plain print ?
  1. procedure  TOverlapThread . Execute;  
  2. var   
  3. 　dwTemp : DWORD;  
  4. 　ret : Integer;  
  5. 　Index : DWORD;  
  6. begin   
  7. 　......  
  8.   
  9. 　while  (  not  Terminated )  do   
  10. 　begin   
  11. 　　Index := WSAWaitForMultipleEvents( FLinks. Count, @FLinks . Events[ 0 ], FALSE, RECV_TIME_OUT, FALSE );  
  12. 　　Dec( Index, WSA_WAIT_EVENT_0 );  
  13. 　　if  Index > WSA_MAXIMUM_WAIT_EVENTS- 1   then   //超时或者其他错误   
  14. 　　　continue;  
  15.   
  16. 　　WSAResetEvent( FLinks. Events[Index] );  
  17. 　　WSAGetOverlappedResult( FLinks. Sockets[Index], FLinks . pOverlaps[Index], @dwTemp, FALSE,FLinks . pdwFlags[Index]^ );  
  18.   
  19. 　　if  dwTemp =  0   then   //连接已经关闭   
  20. 　　begin   
  21. 　　　......  
  22. 　　　continue;  
  23. 　　end   else   
  24. 　begin   
  25. 　　fmMain. ListBox1 . Items . Add( FLinks . pBufs[Index]^.buf );  
  26. 　end ;  
  27.   
  28. 　//初始化缓冲区   
  29. 　FLinks. pdwFlags[Index]^ :=  0 ;  
  30. 　FillChar( FLinks. pOverlaps[Index]^, sizeof(WSAOVERLAPPED),  0  );  
  31. 　FLinks. pOverlaps[Index]^.hEvent := FLinks . Events[Index];  
  32. 　FillChar( FLinks. pBufs[Index]^.buf^, BUFFER_SIZE,  0  );  
  33.   
  34. 　//递一个接收数据请求   
  35. 　WSARecv( FLinks. Sockets[Index], FLinks . pBufs[Index],  1 , FLinks . pdwRecvd[Index]^, FLinks . pdwFlags[Index]^, FLinks . pOverlaps[Index],  nil  );  
  36. end ;  
  37. end ;   





五：Overlapped I/O 完成例程模型

　 　老陈接收到新的信件后，一般的程序是：打开信封----掏出信纸----阅读信件----回复信件......为了进一步减轻用户负担，微软又开发了一 种新的技术：用户只要告诉微软对信件的操作步骤，微软信箱将按照这些步骤去处理信件，不再需要用户亲自拆信/阅读/回复了！老陈终于过上了小资生活！

　　Overlapped I/O 完成例程要求用户提供一个回调函数，发生新的网络事件的时候系统将执行这个函数：

view plain print ?
  1. procedure  WorkerRoutine(  const  dwError, cbTransferred : DWORD;   
  2. const   
  3. lpOverlapped : LPWSAOVERLAPPED; const  dwFlags : DWORD ); stdcall;   
  4.   
  5. 　　//然后告诉系统用WorkerRoutine函数处理接收到的数据：   
  6.   
  7. WSARecv( m_socket, @FBuf, 1 , dwTemp, dwFlag, @m_overlap, WorkerRoutine );   
  8.   
  9. 　　//然后......没有什么然后了，系统什么都给你做了！微软真实体贴！   
  10.   
  11. while  (  not  Terminated )  do //这就是一个Recv/Send线程要做的事情......什么都不用做啊！！！   
  12. begin   
  13. 　if  SleepEx( RECV_TIME_OUT, True ) = WAIT_IO_COMPLETION  then   //   
  14. 　begin   
  15. 　　;  
  16. 　end   else   
  17. 　begin   
  18. 　　continue;  
  19. 　end ;  
  20. end ;   


　　六：IOCP 模型

　　微软信箱似乎很完美，老陈也很满意。但是在一些大公司情况却完全不同！这些大公司有数以万计的信箱，每秒钟都有数以百计的信件需要处理，以至于微软信箱经常因超负荷运转而崩溃！需要重新启动！微软不得不使出杀手锏......

　　微软给每个大公司派了一名名叫“Completion Port”的超级机器人，让这个机器人去处理那些信件！

　 　“Windows NT小组注意到这些应用程序的性能没有预料的那么高。特别的，处理很多同时的客户请求意味着很多线程并发地运行在系统中。因为所有这些线程都是可运行的 [没有被挂起和等待发生什么事]，Microsoft意识到NT内核花费了太多的时间来转换运行线程的上下文[Context]，线程就没有得到很多 CPU时间来做它们的工作。大家可能也都感觉到并行模型的瓶颈在于它为每一个客户请求都创建了一个新线程。创建线程比起创建进程开销要小，但也远不是没有 开销的。我们不妨设想一下：如果事先开好N个线程，让它们在那hold[堵塞]，然后可以将所有用户的请求都投递到一个消息队列中去。然后那N个线程逐一 从消息队列中去取出消息并加以处理。就可以避免针对每一个用户请求都开线程。不仅减少了线程的资源，也提高了线程的利用率。理论上很不错，你想我等泛泛之 辈都能想出来的问题，Microsoft又怎会没有考虑到呢?”-----摘自nonocast的《理解I/O Completion Port》

　　先看一下IOCP模型的实现：

view plain print ?
  1. //创建一个完成端口   
  2. FCompletPort := CreateIoCompletionPort( INVALID_HANDLE_VALUE, 0 , 0 , 0  );  
  3.   
  4. //接受远程连接，并把这个连接的socket句柄绑定到刚才创建的IOCP上   
  5. AConnect := accept( FListenSock, addr , len);  
  6. CreateIoCompletionPort( AConnect, FCompletPort, nil ,  0  );  
  7.   
  8. //创建CPU数*2 + 2个线程    
  9. for  i:= 1   to  si . dwNumberOfProcessors* 2 + 2   do   
  10. begin   
  11. 　AThread := TRecvSendThread. Create(  false  );  
  12. 　AThread. CompletPort := FCompletPort; //告诉这个线程，你要去这个IOCP去访问数据   
  13. end ;   
  14.   
  15. 　　//就这么简单，我们要做的就是建立一个IOCP，把远程连接的socket句柄绑定到刚才创建的IOCP上，最后创建n个线程，并告诉这n个线程到这个IOCP上去访问数据就可以了。   
  16.   
  17. 　　//再看一下TRecvSendThread线程都干些什么：   
  18.   
  19. procedure  TRecvSendThread . Execute;  
  20. var   
  21. 　......  
  22. begin   
  23. 　while  ( not  self . Terminated)  do   
  24. 　begin   
  25. 　　//查询IOCP状态（数据读写操作是否完成）    
  26. 　　GetQueuedCompletionStatus( CompletPort, BytesTransd, CompletKey, POVERLAPPED(pPerIoDat), TIME_OUT );  
  27.   
  28. 　　if  BytesTransd <>  0   then   
  29. 　　　....;//数据读写操作完成   
  30. 　　  
  31. 　　　//再投递一个读数据请求   
  32. 　　　WSARecv( CompletKey, @(pPerIoDat^.BufData), 1 , BytesRecv, Flags, @(pPerIoDat^.Overlap),  nil  );  
  33. 　　end ;  
  34. end ;   


　　读写线程只是简单地检查IOCP是否完成了我们投递的读写操作，如果完成了则再投递一个新的读写请求。

　　应该注意到，我们创建的所有TRecvSendThread都在访问同一个IOCP（因为我们只创建了一个IOCP），并且我们没有使用临界区！难道不会产生冲突吗？不用考虑同步问题吗？

　　这正是IOCP的奥妙所在。IOCP不是一个普通的对象，不需要考虑线程安全问题。它会自动调配访问它的线程：如果某个socket上有一个线程A正在访问，那么线程B的访问请求会被分配到另外一个socket。这一切都是由系统自动调配的，我们无需过问.

wallacexiang
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
socket select 模型
12-18
socket select 模型 用法
socket select()用法
winson的专栏
03-15 2523
一、winsock中#include 原型int select(int nfds,fd_set* readfds,fd_set* writefds,fd_set* exceptfds,const struct timeval* timeout);nfds：本参数忽略，仅起到兼容作用。   readfds：（可选）指针，指向一组等待可读性检查的套接口。   writefds：（可选）
Socket的select模型
weixin_34289454的博客
07-04 63
  注意点:发送的时候字节数不要发送…我就悲剧的测试数据发错了，以为哪出问题了 思路： 初始化一个socket 建立一个socket列表用于管理socket 将初步连接的socket放入列表中 用select判断列表中未处理的socket Win API版本 1. USHORT nPort = 4567; // 此服务器监听的端口号 ...
socket select
简单生活
10-10 872
作一个tcp的服务程序，同时可能有大量的客户端连上来，希望分别记住各个socket 谁有数据过来，就读出来，放到一个请求队列－－这些事情用一个线程完成 另外有一个结果队列，如果结果里包含了socket的编号，用一个线程专门： 取出来按编号找回原来发送者socket，发回给原来的客户端 还有一个就是处理线程（池），它取出请求队列里的一个请求，进行处理， 把处理结果放入结果队列
1_WINSOCK的I/O模型_
10-03
5. **异步I/O**：WINSOCK的`WSAAsyncSelect()`或`WSAEventSelect()`提供异步I/O模型。在这种模型中，操作系统会在数据准备好时完成I/O操作，然后通过事件或消息通知应用程序。异步I/O可以最大限度地提高服务器的并发...
介绍当前Windows支持的各种Socket I/O模型
11-25
本文将详细介绍当前Windows系统中支持的各种Socket I/O模型，包括select、WSAAsyncSelect、WSAEventSelect、Overlapped I/O（重叠IO模型）以及IOCP模型，并通过代码示例来进一步解释它们的工作原理及应用场景。...
select I/O模型 客户端
09-01
这意味着开发者还需要配合其他非阻塞I/O技术，如`WSAAsyncSelect`或`WSAEventSelect`（在Winsock中），以实现完整的异步I/O模型。 总结来说，`select` I/O模型在客户端应用中扮演着关键角色，它帮助开发者高效地...
Windows Socket五种I/O模型——代码全攻略
07-29
选择I/O模型基于`select()`函数，能够监控多个套接字的I/O事件。当某一个或多个套接字准备好读写操作时，`select()`会返回，从而使得可以同时处理多个客户端的连接请求。 **示例代码：** ```c // 创建监听套接字 ...
select选择模型 windows套接字I/O模型
05-13
4. 对于大型系统，可能需要考虑使用更高效的I/O模型，如epoll（在Linux中）或WSAAsyncSelect/WSAEventSelect（在Windows中）。 总结来说，select选择模型是Windows套接字I/O中的一个关键工具，尤其适用于需要高效...
深入理解socket中的select模型
08-09
对于套接字socket 的 select 模型，做了几种模式的解释，为SOCKET编程提供参考指导
Socket Select
l799623787的专栏
09-18 412
http://blog.csdn.net/qiume/article/details/5614148   老陈有一个在外地工作的女儿，不能经常回来，老陈和她通过信件联系。他们的信会被邮递员投递到他们的信箱里。 　　这和Socket模型非常类似。下面我就以老陈接收信件为例讲解Socket I/O模型。 　　一：select模型 　　老陈非常想看到女儿的信。以至于他每隔10
select、poll、epoll
echoisland的专栏
05-05 1259
<br /><br />版权声明：转载时请以超链接形式标明文章原始出处和作者信息及本声明<br />http://xufish.blogbus.com/logs/72686176.html<br /> select<br />select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。<br />select目前几乎在所有的平台上支
socket 之【select】
wjydym的博客
07-12 1784
Select在Socket编程中还是比较重要的，可是对于初学Socket的人来说都不太爱用Select写程序，他们只是习惯写诸如 connect、accept、recv或recvfrom这样的阻塞程序（所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回）。可是使用Select就可以完成非阻塞...
socket的select函数
weixin_30786657的博客
12-15 161
思路： 初始化一个socket 建立一个socket列表用于管理socket 将初步连接的socket放入列表中 用select判断列表中未处理的socket Win API版本 1. USHORT nPort = 4567; // 此服务器监听的端口号// 创建监听套节字SOCKET sListen = ::socket(AF_INET, SOCK_STREAM,...
Linux中Socket的select
timequark的专栏
05-03 3297
 select()的机制中提供一fd_set的数据结构，实际上是一long类型的数组，每一个数组元素都能与一打开的文件句柄（不管是Socket句柄,还是其他 文件或命名管道或设备句柄）建立联系，建立联系的工作由程序员完成，当调用select()时，由内核根据IO状态修改fd_set的内容，由此来通知执行了select()的进程哪一Socket或文件可读，下面具体解释：int select(nf
Linux编程之select
weixin_34010566的博客
06-26 1218
select系统调用的的用途是：在一段指定的时间内，监听用户感兴趣的文件描述符上可读、可写和异常等事件。 select 机制的优势 为什么会出现select模型？ 先看一下下面的这句代码： int iResult = recv(s, buffer,1024); 这是用来接收数据的，在默认的阻塞模式下的套接字里，recv会阻塞在那里，直到套接字连接上有数据可读，把数据读到buffer里后recv函数...
socket编程之select
背着行囊去远方的博客
08-30 2758
Linux编程之select： select作用是：在一段指定的时间内，监听用户感兴趣的文件描述符上可读、可写和异常等事件。 1、socket阻塞模式 通常在socket编程中，我们习惯于写connect、accept、recv、recvfrom这样的阻塞程序。如果事件不发生，程序就一直阻塞在那里，无法返回。 2、socket非阻塞模式：select 用select就可以完成...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值