实测Tomcat的几个参数

已于 2023-04-28 21:58:46 修改
阅读量2.8k 收藏 7
点赞数 5
文章标签： tomcat java
于 2022-07-21 08:35:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq447142862/article/details/125904531
版权

参数定义

先来看看Tomcat的几个常见参数定义,如下

参数设置方式默认值含义
acceptCountserver.tomcat.accept-count100接收队列,实质上是在操作系统已经完成三次握手等待accept的socket队列
maxConnectionsserver.tomcat.max-connections8192最大连接数,实质上是指已经accept的socket数量
maxThreadsserver.tomcat.threads.max200用于处理已经accept的socket的线程最大数量
connectionTimeoutserver.tomcat.connection-timeout60000ms是指socket连接后或读取报文字节过程中的超时时间
keepAliveTimeout实现WebServerFactoryCustomizer默认取connectionTimeout在同一个socket连接,处理完一次http请求后,等待下一次http请求的超时时间
MaxKeepAliveRequests实现WebServerFactoryCustomizer100在同一个socket连接,最大处理http请求数量,达到数量后关闭socket

测试代码

服务端是一个SpringBoot的应用,测试代码就是一个sleep5秒的方法,如下

    @PostMapping("/save")
    public String save(@RequestBody String body) throws InterruptedException {
        Thread.sleep(5000);
        return "success";
    }

客户端测试代码,采用SocketHttpClient发送请求,如下

    static ExecutorService getExecutorService() {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 100, 60, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(1), r -> {
            Thread thread = new Thread(r);
            thread.setDaemon(true);
            thread.setName("自定义线程池 " + RandomUtils.nextInt());
            return thread;
        });
        return threadPoolExecutor;
    }

    public static void main(String[] args) throws InterruptedException {

        ExecutorService executorService = getExecutorService();

        SocketHttpRequest socketHttpRequest = new SocketHttpRequest();
        socketHttpRequest.setHost("127.0.0.1");
        socketHttpRequest.setPort(9100);
        socketHttpRequest.setMethod(HttpMethod.POST.name());
        socketHttpRequest.setUrl("/test/save");
        socketHttpRequest.setBody("test");
        final CopyOnWriteArrayList<SendRecord> sendRecordList = new CopyOnWriteArrayList<>();

        int n = 2;
        for (int i = 1; i <= n; i++) {
            SendRecord sendRecord = new SendRecord();
            sendRecord.setId(i);
            int a = i;
            Thread.sleep(200);
            executorService.execute(() -> {
                try {
                    sendRecord.setConnectTime(new Date());
                    SocketHttpClient socketHttpClient = new SocketHttpClient("127.0.0.1", 9100);
                    //Thread.sleep( a*4000);
                    sendRecord.setSendTime(new Date());
                    SocketHttpResponse socketHttpResponse = socketHttpClient.sendRequest(socketHttpRequest);
                    sendRecord.setResult(socketHttpResponse.getBody());
//                    try {
//                        Thread.sleep(1000);
//                        socketHttpResponse = socketHttpClient.sendRequest(socketHttpRequest);
//                        System.out.println("同一socket连接,间隔1秒后第二次请求结果:" + socketHttpResponse.getBody());
//                    } catch (Exception ex) {
//                        System.out.println("同一socket连接,间隔1秒后第二次请求结果:" + ex.getMessage());
//                    }
                    socketHttpClient.close();
                } catch (Exception e) {
                    sendRecord.setResult(e.getMessage());
                } finally {
                    sendRecord.setEndTime(new Date());
                    sendRecordList.add(sendRecord);
                }
            });
        }

        while (sendRecordList.size() < n) {
            Thread.sleep(1000);
        }
        sendRecordList.stream().sorted(Comparator.comparing(x -> x.getId())).forEach(x -> {
            System.out.println(String.format("id:%s,connectTime:%s,sendTime:%s,endTime:%s,result:%s", x.getId()
                    , DateFormatUtils.format(x.getConnectTime(), "HH:mm:ss.ss")
                    , x.getSendTime() == null ? null : DateFormatUtils.format(x.getSendTime(), "HH:mm:ss.ss")
                    , x.getEndTime() == null ? null : DateFormatUtils.format(x.getEndTime(), "HH:mm:ss.ss"), x.getResult()));
        });
    }
acceptCount和maxConnections
测试1

发送5次请求,参数如下

server.tomcat.accept-count=1
server.tomcat.max-connections=1
server.tomcat.threads.max=100 

id:1,connectTime:10:27:18.18,sendTime:10:27:18.18,endTime:10:27:23.23,result:success
id:2,connectTime:10:27:18.18,sendTime:10:27:18.18,endTime:10:27:28.28,result:success
id:3,connectTime:10:27:18.18,sendTime:null,endTime:10:27:20.20,result:Connection refused: connect
id:4,connectTime:10:27:18.18,sendTime:null,endTime:10:27:20.20,result:Connection refused: connect
id:5,connectTime:10:27:18.18,sendTime:null,endTime:10:27:21.21,result:Connection refused: connect

第一到达服务端的请求是id1,这时已经达到最大连接数,id2只能在accept队列等待,这时accept队列也满了,所以后面三次请求连接被操作系统拒绝了

测试2

发送5次请求,参数如下

server.tomcat.accept-count=1
server.tomcat.max-connections=2
server.tomcat.threads.max=100

id:1,connectTime:10:29:48.48,sendTime:10:29:49.49,endTime:10:29:54.54,result:success
id:2,connectTime:10:29:49.49,sendTime:10:29:49.49,endTime:10:29:54.54,result:success
id:3,connectTime:10:29:49.49,sendTime:10:29:49.49,endTime:10:29:59.59,result:success
id:4,connectTime:10:29:49.49,sendTime:null,endTime:10:29:51.51,result:Connection refused: connect
id:5,connectTime:10:29:49.49,sendTime:null,endTime:10:29:51.51,result:Connection refused: connect

id1和id2的处理完成时间相同,说明同时都在connection队列中被处理,id3处理完成时间在5秒后,说明在accept队列等待了5秒才进入connection队列,然后剩下两个请求因为accept和onnection队列都满了,所以都拒绝了

测试3

发送5次请求,参数如下

server.tomcat.accept-count=2
server.tomcat.max-connections=2
server.tomcat.threads.max=100

id:1,connectTime:10:31:38.38,sendTime:10:31:39.39,endTime:10:31:44.44,result:success
id:2,connectTime:10:31:39.39,sendTime:10:31:39.39,endTime:10:31:44.44,result:success
id:3,connectTime:10:31:39.39,sendTime:10:31:39.39,endTime:10:31:49.49,result:success
id:4,connectTime:10:31:39.39,sendTime:10:31:39.39,endTime:10:31:49.49,result:success
id:5,connectTime:10:31:39.39,sendTime:null,endTime:10:31:41.41,result:Connection refused: connect

相比测试2,多了id4在accept队列等待,符合预期

测试4

并发发送5次请求,参数如下

server.tomcat.accept-count=1
server.tomcat.max-connections=1
server.tomcat.threads.max=100

id:1,connectTime:10:54:18.18,sendTime:10:54:18.18,endTime:10:54:43.43,result:success
id:2,connectTime:10:54:18.18,sendTime:10:54:18.18,endTime:10:54:23.23,result:success
id:3,connectTime:10:54:18.18,sendTime:10:54:18.18,endTime:10:54:33.33,result:success
id:4,connectTime:10:54:18.18,sendTime:10:54:18.18,endTime:10:54:28.28,result:success
id:5,connectTime:10:54:18.18,sendTime:10:54:18.18,endTime:10:54:38.38,result:success

相比测试1,改成并发发送五次请求,按道理应该有三次是连接拒绝的,但是实测结果都成功了,查看处理结束时间都是间隔5秒,说明同一时间只有一个请求在connection队列,是accept队列没控制住了,五次请求都被accept队列接收了

maxThreads
测试5

发送5次请求,参数如下

server.tomcat.accept-count=2
server.tomcat.max-connections=2
server.tomcat.threads.max=1

id:1,connectTime:10:35:43.43,sendTime:10:35:43.43,endTime:10:35:48.48,result:success
id:2,connectTime:10:35:43.43,sendTime:10:35:43.43,endTime:10:35:53.53,result:success
id:3,connectTime:10:35:43.43,sendTime:10:35:43.43,endTime:10:35:58.58,result:success
id:4,connectTime:10:35:43.43,sendTime:10:35:43.43,endTime:10:36:03.03,result:success
id:5,connectTime:10:35:44.44,sendTime:null,endTime:10:35:46.46,result:Connection refused: connect

相比测试3,最大处理线程变成1,所以id1~id4的处理完成时间依次延后5秒,符合预期

connectionTimeout
测试6
server.tomcat.connection-timeout=5000
server.tomcat.accept-count=1
server.tomcat.max-connections=1
server.tomcat.threads.max=100

客户端增加代码

SocketHttpClient socketHttpClient = new SocketHttpClient("127.0.0.1", 9100);
Thread.sleep(4000);

id:1,connectTime:11:16:17.17,sendTime:11:16:21.21,endTime:11:16:26.26,result:success

socket连接成功后,4秒后才发送请求,响应成功,符合预期

测试7
server.tomcat.connection-timeout=5000
server.tomcat.accept-count=1
server.tomcat.max-connections=1
server.tomcat.threads.max=100

客户端增加代码

SocketHttpClient socketHttpClient = new SocketHttpClient("127.0.0.1", 9100);
Thread.sleep(7000);

id:1,connectTime:11:15:47.47,sendTime:11:15:54.54,endTime:11:15:54.54,result:Software caused connection abort: socket write error

socket连接成功后,7秒后才发送报文,超过设置connection-timeout=5000,发生socket异常,说明服务端的socket连接读取超时关闭了,符合预期

测试8

SocketHttpClient修改代码

      //添加请求行
        headStringBuffer.append(socketHttpRequest.getMethod()).append(" ").append(socketHttpRequest.getUrl()).append(" ").append("HTTP/1.1").append("\r\n");
        out.write(headStringBuffer.toString());
        out.flush();
        Thread.sleep(7000);
        StringBuffer sb = new StringBuffer();

相比测试7,写入请求行后,延迟7秒后才写请求头,也发生socket异常.这就说明无论在连接成功后延迟,还是传输报文的过程中有延迟,都是会触发服务端的connectTimeout异常

测试9
SocketHttpClient socketHttpClient = new SocketHttpClient("127.0.0.1", 9100);
Thread.sleep(a*4000);

id:1,connectTime:14:20:09.09,sendTime:14:20:13.13,endTime:14:20:18.18,result:success
id:2,connectTime:14:20:09.09,sendTime:14:20:17.17,endTime:14:20:23.23,result:success

这次测试连续发送两次请求,第二次socket连接成功8秒后才发送报文,但是也成功响应了,看似不符合connection-timeout=5000的限制,但是要看id1的结束时间是14:20:18,在这之前id2一直在accept队列等待,并没有在connection队列.所以connectionTimeout的计算规则应为socket进入connection队列才开始计时.

keepAliveTimeout
测试10
protocol.setKeepAliveTimeout(10000);

            sendRecord.setResult(socketHttpResponse.getBody());
               try {
                        Thread.sleep(7000);
                        socketHttpResponse = socketHttpClient.sendRequest(socketHttpRequest);
                        System.out.println("同一socket连接,间隔7秒后第二次请求结果:" + socketHttpResponse.getBody());
                    } catch (Exception ex) {
                        System.out.println("同一socket连接,间隔7秒后第二次请求结果:" + ex.getMessage());
                    }

同一socket连接,间隔7秒后第二次请求结果:success
id:1,connectTime:17:04:17.17,sendTime:17:04:17.17,endTime:17:04:34.34,result:success

同一socket,第二次请求延迟7秒,小于KeepAliveTimeout的10秒,响应正常,符合预期

测试11
protocol.setKeepAliveTimeout(10000);

            sendRecord.setResult(socketHttpResponse.getBody());
               try {
                        Thread.sleep(12000);
                        socketHttpResponse = socketHttpClient.sendRequest(socketHttpRequest);
                        System.out.println("同一socket连接,间隔12秒后第二次请求结果:" + socketHttpResponse.getBody());
                    } catch (Exception ex) {
                        System.out.println("同一socket连接,间隔12秒后第二次请求结果:" + ex.getMessage());
                    }

同一socket连接,间隔12秒后第二次请求结果:Software caused connection abort: socket write error
id:1,connectTime:17:04:52.52,sendTime:17:04:52.52,endTime:17:05:09.09,result:success

同一socket,第二次请求延迟12秒,大于KeepAliveTimeout的10秒,socket写入失败,也符合预期

MaxKeepAliveRequests
测试12
protocol.setMaxKeepAliveRequests(1);

 try {
                        Thread.sleep(1000);
                        socketHttpResponse = socketHttpClient.sendRequest(socketHttpRequest);
                        System.out.println("同一socket连接,间隔1秒后第二次请求结果:" + socketHttpResponse.getBody());
                    } catch (Exception ex) {
                        System.out.println("同一socket连接,间隔1秒后第二次请求结果:" + ex.getMessage());
                    }


同一socket连接,间隔1秒后第二次请求结果:Software caused connection abort: socket write error

同一socket,第二次请求失败,大于MaxKeepAliveRequests的1次,socket写入失败,符合预期

测试13
protocol.setMaxKeepAliveRequests(2);

 try {
                        Thread.sleep(1000);
                        socketHttpResponse = socketHttpClient.sendRequest(socketHttpRequest);
                        System.out.println("同一socket连接,间隔1秒后第二次请求结果:" + socketHttpResponse.getBody());
                    } catch (Exception ex) {
                        System.out.println("同一socket连接,间隔1秒后第二次请求结果:" + ex.getMessage());
                    }


同一socket连接,间隔1秒后第二次请求结果:success

相比测试12,MaxKeepAliveRequests改成2,响应成功,符合预期

源码简析

上面测试都是基于客户端,对服务端进行黑盒测试的,现在我们来看看那几个参数在Tomcat的源码中哪里.

  • acceptCount,相关代码可以查看org.apache.tomcat.util.net.NioEndpoint.initServerSocket(),它决定了Socket中连接队列backlog的值,关于backlog,不同操作系统有不同的实现,上面测试5是在window环境上的,可能linux结果可能会有所不同
  • maxConnections,相关代码可以查看org.apache.tomcat.util.net.Acceptor.run 和org.apache.tomcat.util.net.AbstractEndpoint.countUpOrAwaitConnection,Tomcat开启了一个accept线程,通过countUpOrAwaitConnection方法判断是否达到maxConnection,然后从serverSocketChannel中获取连接,放在org.apache.tomcat.util.net.AbstractEndpoint.connections列表中
  • maxThreads,相关代码可以查看org.apache.tomcat.util.net.AbstractEndpoint.setMaxThreads,Tomcat创建了最大线程为maxThreads的线程池executor.另外,Tomcat也启动了org.apache.tomcat.util.net.NioEndpoint.Poller的线程,负责将已经accept的socket封装在org.apache.tomcat.util.net.NioEndpoint.SocketProcessor,指派给executor线程池处理
  • connectionTimeout和keepAliveTimeout 相关代码可以查看org.apache.tomcat.util.net.NioEndpoint.Poller.timeout方法,这个方法里面不断轮询所有注册到Poller的socketChannel,如果最后一次读取时间到当前时间大于timeout时间,则结束socket连接.这个timeout可能是connectionTimeout和keepAliveTimeout,具体是读取哪个值,要看字节读取阶段,相关逻辑在org.apache.coyote.http11.Http11Processor.service方法中
  • MaxKeepAliveRequests,也是在org.apache.coyote.http11.Http11Processor.service方法,当请求达到MaxKeepAliveRequests的值时,会将keepAlive改为flase,然后退出读取当前socket的循环

简单来说,Tomcat启动的时候,会实例化ServerSocketChannel监听端口,创建一个线程池executor和启动两个线程ClientPoller和Acceptor,Acceptor负责将连接成功的tcp连接取出,注册到ClientPoller中,ClientPoller负责轮询所有channel,当有可读事件,就将可读的socketChannel转交给executor处理,executor会分配一个名为xx-exec-xx的线程去处理,这exec线程主要是从SocketChannel中读取字节,解析成HTTP报文,封装成Request传递下去,后面的链路主要就是我们比较熟悉的Filter链,DispatcherServlet和Controller了

Caizil
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
apache、tomcat整合及并发测试
09-28
apache、tomcat整合及并发测试、及相关mod_jk文件下载、包含mod_jk-apache-2.2.4.so文件。httpd.conf/http_vhosts.conf/workers.properties配置
巷道承压收敛实测分析与支护参数优化
06-11
为改善巷道支护效果,更好地保障矿井安全生产,对黄陵一号煤矿308工作面回采辅运巷围岩发生的变形破断情况进行分析总结,得出巷道变形破坏规律及破坏...基于现场观测及分析,对巷道支护参数进行优化,取得了较好的支护效果。
Tomcat Connector connectionTimeout含义和验证
weixin_30332705的博客
02-04 686
Tomcat Connector connectionTimeout含义和验证1. Tomcat配置 线上系统中tomcat的连接超时（connectionTimeout）设置成60ms，造成第三方访问公司的服务，总是502异常。 这个设置在$tomcat/conf/server.xml中<!-- Define a non-SSL HTTP/1.1 Connector on port ...
tomcat的maxThreads、acceptCount，对高并发的影响
最新发布
2301_77053710的博客
04-30 492
分享一些资料给大家，我觉得这些都是很有用的东西，大家也可以跟着来学习，查漏补缺。《Java高级面试》《Java高级架构知识》《算法知识》[外链图片转存中…(img-oZawbZaC-1714479307784)]《算法知识》[外链图片转存中…(img-NIRlIO6b-1714479307784)]本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录。
tomcat 并发测试
zhanglinlang的专栏
02-28 1318
参考：http://blog.sina.com.cn/s/blog_68b7d2f50101ann7.html 服务器配置： 单硬盘，SATA 8MB缓存 测试服务器和loadrunner运行服务器位于同一网段--100MB网络（同一交换机）上，排除网络问题的影响 服务器运行始终，CPU使用率非常低没有超过5% 因此虽然服务器配置低，但是不是性能瓶颈所在 ...
tomcat并发测试
SAN_YUN的专栏
12-24 282
测试环境： 联想T420笔记本（Intel(R) Core(TM) i3-2350M CPU @ 2.30GHz） 内存6G tomcat5 jetty6   测试代码，一个Servlet，输出一段字符串 public class CacheMonitorView extends HttpServlet { public void service(HttpServlet...
tomcat 并发请求测试
luckstar的专栏
09-11 1292
1, 并发请求测试 ­使用tomcat自带命令进行并发测试 ab -c1000 -n2000 "http://mytest.aa.com/aaa.jsp?userId=zhxzhboy" ­送出1000个并发. 共计2000个请求. ­相应结果会在下面列出来. ­­2, 文件限制修改. ­tomcat打开的最大文件数是有默认的 1024. 多了则会报
Tomcat压力测试
shyu1989的专栏
08-23 2134
转自： Tomcat压力测试 I. 前言 我公司网站的部署使用了Tomcat,网络上关于Linux下Tomcat的性能数据比较少.为了对Tomcat的性能有一个大概的了解,分别对Tomcat和Apache作了多次的压力测试,并将测试的数据进行对比. 每次压力测试大体的测试环境一样,以下说明是每次测试环境中相同的部分,不同的部分在下面的章节另外补充说明. 测试环境说明: 1. 测试工
linux安装tomcat8+项目部署（实测没问题）
05-16
linux安装tomcat8,亲测没有问题，本文档详细介绍了linux下用命令行实现tomcat的安装及项目的部署，小白即可使用
实测实量数据分析.doc
12-06
在建设项目中，实测实量数据分析是一个非常重要的环节。通过对实测数据的分析，可以找出薄弱节点，制定相应整改方案，促进整体质量稳步上升。在本文中，我们将对孝义碧桂园一期项目实测实量数据进行分析，以找出存在...
linux centos安装tomcat 部署javaweb
03-22
虚拟机安装linux centos7安装tomcat 部署javaweb 实测
tomcat 最大并发连接数 acceptCount
01-07
tomcat 最大并发数 并发量 tomcat 最大并发连接数 acceptCount不能说只要大于acceptCount的连接就一定被拒绝！
xx.rar_实测数据
09-20
应用matlab，使实测速度数据转化为频域值，在应用相关函数得到功率谱。
秒懂：tomcat的maxConnections、maxThreads、acceptCount 图解
架构师尼恩
10-27 5681
后面附图 | 秒懂 疯狂创客圈 Java 高并发【 亿级流量聊天室实战】实战系列 【博客园总入口 】 前言 疯狂创客圈（笔者尼恩创建的高并发研习社群）Springcloud 高并发系列文章，将为大家介绍三个版本的 高并发秒杀： 一、版本1 ：springcloud + zookeeper 秒杀 二、版本2 ：springcloud + redis 分布式锁秒杀 三、版本3 ：springclo...
聊聊tomcat的connection-timeout
go4it
11-23 1610
AbstractProtocol将timeout设置到endpoint/***/} else {AbstractEndpoint将timeout设置到socketProperties的soTimeout，另外它的getKeepAliveTimeout方法在keepAliveTimeout为null的时候，使用的是getConnectionTimeout。
Spring boot tomcat优化一些说明
北巷东东的专栏
03-18 1719
spring boot tomcat一些优化说明
关于springboot内置tomcat最大请求数配置的一些问题
fyk的博客
04-27 1066
springboot内置了tomcat。那么一个springboot web应用，最大的请求链接数是多少呢？有哪些配置参数，他们是什么意思呢？
Springboot配置Tomcat运行参数，优化JVM提高系统稳定性
热门推荐
开发者导航
08-21 1万+
我们在使用springboot开发Web项目时，大多时候采用的是内置Tomcat（当然也可以配置支持内置的jetty），内置Tomcat有什么好处呢？1、方便微服务部署，减少繁杂的配置2、方便项目启动，不需要单独下载web容器，如Tomcat，jetty等。针对目前的容器优化，可以从以下几点考虑：1、线程数2、超时时间3、jvm优化首先，线程数是一个重点，比较重要的有两...
HTTP keep-alive及Tomcat配置分析
adrninistrat0r的博客
03-31 3970
1. HTTP协议关于keep-alive的说明 参考“Hypertext Transfer Protocol – HTTP/1.1-8.1 Persistent Connections”( https://tools.ietf.org/html/rfc2616#section-8.1 )。 在持久化连接出现之前，每次访问URL都需要建立一个独立的TCP连接，会增加HTTP服务器的负载，并导致网络拥塞。 持久的HTTP连接有一些优势，例如打开与关闭的TCP连接会减少，可以减少中间经过节点的CPU时间及内存等
还是不对，实测上面e是个元组
06-03
非常抱歉，我的回答还是有误。对于这行代码： ```python a, b = c = d, e ``` 它的含义是将变量d的值赋给变量c，然后将c作为一个元组和变量e一起赋给变量a和b。 具体来说，这行代码等价于以下两行代码： ```python c = d a, b = c, e ``` 其中，变量e应该是一个元组，否则会抛出“TypeError: 'x' object is not iterable”的异常。 例如，如果e是一个包含两个元素的元组，那么这行代码的含义就是将变量d的值赋给变量c，然后将变量c和元组e一起解包，分别赋值给变量a和b。具体来说，这行代码等价于以下一行代码： ```python c = d a, b = c + e ``` 这样，变量a和b的值分别为d和e中的第一个元素和第二个元素。 在Python中，多重赋值语句非常灵活，可以同时给多个变量赋值，例如： ```python a, b = b, a # 交换a和b的值 x, y, z = 1, 2, 3 # 将1赋给x，2赋给y，3赋给z ``` 希望这次回答可以解决你的疑惑。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值