python写的多进程并发测试框架

最新推荐文章于 2024-08-11 10:00:00 发布
最新推荐文章于 2024-08-11 10:00:00 发布
阅读量4k 收藏 8
点赞数 1
分类专栏： 开源、高手、思想
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangtaolmq/article/details/54647214
版权

MultiProcessWrapper.py

# -*- coding: utf-8 -*-
#!/usr/bin/env python
#############################################################
#teaching wisedom to my machine,please call me Croco#
#############################################################
# graceful_exit_event.py
#   UTF-8 without BOM
#
# refer:
#   http://stackoverflow.com/questions/26414704/how-does-a-python-process-exit-gracefully-after-receiving-sigterm-while-waiting?rq=1
#   http://www.cnblogs.com/kaituorensheng/p/4445418.html
# init created: 2016-07-13
# last updated: 2016-07-14
#
#######################################################################
import os
import signal
import multiprocessing
import sys
from abc import ABCMeta,abstractmethod
import time
import traceback


###################################################
#   WorkerInterface
#     定义了一个worker必备的功能接口
###################################################
class WorkerInterface(object):
    __metaclass__ = ABCMeta
    @abstractmethod
    def onStart(self):
        pass
    @abstractmethod
    def onEnd(self,end_code,end_reason):
        pass
    @abstractmethod
    def onRunOnce(self):
        pass
    @abstractmethod
    def onTimer(self):
        pass
    @abstractmethod
    def finished(self):
        pass
    @abstractmethod
    def timeout_ms(self):
        pass
    @abstractmethod
    def log(self,txt):
        pass
    @abstractmethod
    def daemon(self):
        pass



###################################################
#   SimpleWorker
#     基于WorkerInterface实现一个简单的worker，
#     提供使用示例
###################################################
class SimpleWorker(WorkerInterface):
    def __init__(self):
        self.is_finished=False
    def onStart(self):
        t= "SimpleWorker(%d) start ..." % os.getpid()
        self.log(t)
        pass
    def onEnd(self,end_code,end_reason):
        t = "SimpleWorker(%d) end.with reason(%d:%s)" % (os.getpid(),end_code,end_reason)
        self.log(t)
        pass
    def onRunOnce(self):
        t = "SimpleWorker(%d) onRunOnce" % (os.getpid())
        self.log(t)
        self.is_finished=True
        pass
    def onTimer(self):
        t = "SimpleWorker(%d) onTimer" % (os.getpid())
        self.log(t)
        pass
    def finished(self):
        return self.is_finished
    def done(self):
        self.is_finished=True

    def timeout_ms(self):
        return 3000
    def log(self,txt):
        print "=>", txt
        pass
    def daemon(self):
        return True


###################################################
#   GracefulExitException
#
###################################################
class GracefulExitException(Exception):
    @staticmethod
    def sigterm_handler(signum, frame):
        raise GracefulExitException()
    pass

###################################################
#   GracefulExitException
#
###################################################
class GracefulExitEvent(object):
    def __init__(self):
        self.workers = []
        self.exit_event = multiprocessing.Event()

        # Use signal handler to throw exception which can be caught
        # by worker process to allow graceful exit.
        signal.signal(signal.SIGTERM, GracefulExitException.sigterm_handler)
        pass

    def reg_worker(self, wp):
        self.workers.append(wp)
        pass

    def is_stop(self):
        return self.exit_event.is_set()

    def notify_stop(self):
        self.exit_event.set()

    def wait_all(self):
        while True:
            try:
                for wp in self.workers:
                    print "main process({0}) observe child status=>name:{1} pid:{2} is_alive:{3}".format(os.getpid(), wp.name,wp.pid,wp.is_alive(),)
                    wp.join()
                print "main process(%d) exit." % os.getpid()
                break
            except GracefulExitException:
                self.notify_stop()
                print "main process(%d) got GracefulExitException." % os.getpid()
            except Exception, ex:
                self.notify_stop()
                print "main process(%d) got unexpected Exception: %r" % (os.getpid(), ex)
                break
        pass


#######################################################################
def worker_proc(gee,worker_interface=SimpleWorker()):
    try:
        worker_interface.onStart()
        last = int(time.time()*1000)
        while not gee.is_stop():
            worker_interface.onRunOnce()
            if worker_interface.finished():
                worker_interface.onEnd(0, "finished")
                break
            current = int( time.time() * 1000)
            if current >= last+worker_interface.timeout_ms():
                worker_interface.onTimer()
                last=current
        else:
            worker_interface.onEnd(1,"got parent exit notify")
    except GracefulExitException:
        t= "got graceful exit exception"
        worker_interface.onEnd(-1,t)
    except Exception, ex:
        t = "caught unhandle exception\n"
        info = sys.exc_info()
        for file, lineno, function, text in traceback.extract_tb(info[2]):
            t += "{0} line:{1} in function:{2}\n".format(file, lineno, function)
            t += text+"\n"
            t += "** %s: %s" % info[:2]
            t += "\n"
        worker_interface.onEnd(-2, t)
    finally:
        worker_interface.onEnd(2,"exit")
        sys.exit(0)


#######################################################################
class MultiProcessWrapper(object):
    def __init__(self):
        pass
    # Start some workers process and run forever
    def startAsForver(self,worker_interface_array=list()):
        gee = GracefulExitEvent()
        for worker_interface in   worker_interface_array:
            wp = multiprocessing.Process(target=worker_proc, args=(gee,worker_interface))
            wp.daemon=worker_interface.daemon()
            wp.start()
            gee.reg_worker(wp)
        gee.wait_all()


if __name__ == "__main__":
    print "main process(%d) start" % os.getpid()
    # p=MultiProcessWrapper()
    # p.startAsForver(SimpleWorker()      )
    # print "main process(%d) end" % (os.getpid())





TestHttpMain.py
# -*- coding: utf-8 -*-
# !/usr/bin/env python
#############################################################
# teaching wisedom to my machine,please call me Croco#
#  这是一个多进程并发的压力测试程序框架
#  注意不要把进程数设置大于10000，这容易把机器跑卡死。
#############################################################

import HttpModule
import MultiProcessWrapper
import os
import sys
import time
from multiprocessing.sharedctypes import Array
import ctypes
import socket
socket.setdefaulttimeout(3)

'''
GLOBAL Vars
'''

WORKER_COUNT=3
REQ_MAX_COUNT=1000
USE_MAX_TIME =12000
REQ = 'GET / HTTP/1.1\r\nAccept-Encoding: identity\r\nHost: 127.0.0.1\r\nConnection: close\r\nUser-Agent: Python-urllib/2.7\r\n\r\n'
REQ = 'GET / HTTP/1.1\r\nAccept-Encoding: identity\r\nHost: 127.0.0.1\r\nConnection: keep-alive\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36\r\n\r\n'
REQ = 'GET / HTTP/1.1\r\nAccept-Encoding: identity\r\nHost: 127.0.0.1\r\nConnection: keep-alive\r\nUser-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36\r\n\r\n'
# req='GET / HTTP/1.1\r\nAccept-Encoding: identity\r\nHost: 127.0.0.1\r\nConnection: keep-alive\r\nUser-Agent: Python-urllib/2.7\r\n\r\n'





def current_ms():
    return int(time.time() * 1000)

'''
############################################
class WorkerData
    定义Worker工作结束后的状态数据，该数据
    存储在share mempory ,便于全部worker结束后
    main process做汇总
############################################
'''
class WorkerData(ctypes.Structure):
    _fields_ = [('worker_id', ctypes.c_long),
                ('reqcount', ctypes.c_long),
                ('rspcount', ctypes.c_long),
                ('rspokcount', ctypes.c_long),
                ('sendbytes', ctypes.c_long),
                ('recvbytes', ctypes.c_long),
                ('startms', ctypes.c_long),
                ('endms', ctypes.c_long),
                ]

    @staticmethod
    def createWorkerDataList(worker_count):
        worker_data_list = []
        for i in xrange(worker_count):
            w = WorkerData()
            w.worker_id = -1
            w.reqcount = 0
            w.rspcount = 0
            w.rspokcount = 0
            w.startms = 0
            w.endms = 0
            w.sendbytes = 0
            w.recvbytes = 0
            worker_data_list.append(w)
        return worker_data_list


def normalizeNetIO(total_bytes, total_ms):
    if total_ms == 0:
        return "error net io"
    speed = total_bytes / total_ms
    speed = speed * 1000
    if speed < 1024:
        return "{0}Bytes/s".format(speed)
    if 1024 <= speed < 1048576:
        return "{0}KB/s".format(speed / 1024)
    return "{0}MB/s".format(speed / 1048576)

'''
############################################
gatherResult()
    main process做汇总的函数
############################################
'''
def gatherResult(g_share_array, worker_count):
    print "--> gather result---"
    reqcount = 0
    rspcount = 0
    rspokcount = 0
    sendbytes = 0
    recvbytes = 0
    use_ms = 0
    for i in xrange(worker_count):
        s = g_share_array[i]
        print s.worker_id, s.reqcount, s.rspcount, s.rspokcount, s.startms, s.endms, s.sendbytes, s.recvbytes
        reqcount += s.reqcount
        rspcount += s.rspcount
        rspokcount += s.rspokcount
        sendbytes += s.sendbytes
        recvbytes += s.recvbytes
        tmp_ms = s.endms - s.startms
        if tmp_ms > use_ms:
            use_ms = tmp_ms
    result = "------------------------------------------\n"
    result += "worker count:{0}\n".format(worker_count)
    result += "total reqcount:{0}\n".format(reqcount)
    result += "total rspcount:{0}\n".format(rspcount)
    result += "total rspokcount:{0}\n".format(rspokcount)
    result += "total use_ms:{0}\n".format(use_ms)
    result += "total sendbytes:{0}\n".format(sendbytes)
    result += "total recvbytes:{0}\n".format(recvbytes)
    tps = 0
    if use_ms > 0:
        tps = rspcount / use_ms
    result += "averge tps:{0}\n".format(tps * 1000)
    result += "averge sendspeed:{0}\n".format(normalizeNetIO(sendbytes, use_ms))
    result += "averge recvspeed:{0}\n".format(normalizeNetIO(recvbytes, use_ms))
    result += "=========================================\n"
    print result
    with open("result.txt", 'a') as f:
        f.write(result)
    print "Everying is Finished!"



'''
############################################
class HttpTestWorker
    实现了WorkerInterface，是一个worker进程实质
    运行的类
############################################
'''
class HttpTestWorker(MultiProcessWrapper.SimpleWorker):
    def __init__(self, worker_id, share_array):
        global REQ_MAX_COUNT
        self.worker_id = worker_id
        self.share_array = share_array
        self.is_finished = False
        self.reqcount = 0
        self.rspcount = 0
        self.reqmaxcount = REQ_MAX_COUNT
        self.rspokcount = 0
        self.sendbytes = 0
        self.recvbytes = 0
        self.startms = current_ms()
        self.rsponsetime = 0
        super(HttpTestWorker, self).__init__()

    def onStart(self):
        t = "HttpTestWorker(%d) start ..." % os.getpid()
        self.log(t)
        self.buildConnection(addr=("127.0.0.1", 80))
        pass

    def onEnd(self, end_code, end_reason):
        print end_reason
        # t = "HttpTestWorker(%d) end.withreason:%d\n%s" % (os.getpid(),end_code,end_reason)
        # self.log(t)
        # use_ms = current_ms() - self.startms
        # print "HttpTestWorker({0}) finishd  use_ms:{1}.".format(os.getpid(),use_ms)
        if end_code == 2:
            self.onExit()
        pass

    def report(self):
        use_ms = current_ms() - self.startms
        if use_ms == 0:
            return
        s_speed = normalizeNetIO(self.sendbytes,use_ms)
        r_speed = normalizeNetIO(self.recvbytes,use_ms)
        tps  =  self.rspcount*1000/use_ms
        print "report id:{0} req:{1} rsptime:{2} sspeed:{3} rspeed:{4} tps:{5}".format(os.getpid(), self.reqcount, self.rsponsetime,s_speed,r_speed,tps)

    def onRunOnce(self):
        global REQ
        global USE_MAX_TIME
        # in_data="zhangtao"
        # url="http://127.0.0.1:5000/user/{0}".format(in_data)
        url = "http://127.0.0.1"
        self.reqcount += 1
        # response = HttpModule.doHttpGetRequest(url)
        response = self.ioCtrlMockHttpGet(REQ)
        # print response
        # print len(response)
        self.rspcount += 1
        if response and len(response) >= 1:
            self.rspokcount += 1
        if 1 == 0 or self.reqcount >= self.reqmaxcount or current_ms() > self.startms + USE_MAX_TIME:
            self.report()
            self.done()
        if self.reqcount % 1000 == 0:
            self.report()

        pass

    def buildConnection(self, addr=("127.0.0.1", 80)):
        self.clientSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        try:
            self.clientSocket.connect(addr)
            print "TcpConnector connect succ:", addr
        except:
            (ErrorType, ErrorValue, ErrorTB) = sys.exc_info()
            print "Connect server failed: ", ErrorValue, addr
            self.clientSocket.close()
            self.clientSocket = None
            sys.exit(1)

    # 模拟HTTPGET的请求的IOCtrl
    def ioCtrlMockHttpGet(self, req=""):
        t1 = time.time()
        if not self.clientSocket:
            print "worker:{0} socketerror,or connection is reset,or cannot connect to server".format(os.getpid())
            sys.exit(100)
            return ""
        ret = self.clientSocket.send(req)
        if ret != len(req):
            print "worker:{0} senderror".format(os.getpid())
            sys.exit(102)
            return ""
        self.sendbytes += ret

        recvbuf = ""
        headsize = 0
        totalsize = 0
        while True:
            rsp = self.clientSocket.recv(512)
            if len(rsp) == 0:
                print "worker:{0} recv zero1".format(os.getpid())
                sys.exit(103)
            recvbuf += rsp
            rsp = recvbuf
            p = rsp.rfind("\r\n\r\n")
            if p < 0:
                continue
            headsize = p + 4
            p1 = rsp.find("Content-Length: ")
            if p1 < 0:
                print "worker:{0} cannot find Content-Length,check  httpheader".format(os.getpid())
                sys.exit(104)
            p2 = rsp.find("\r\n", p1 + 16)
            if p2 < 0:
                print "worker:{0} cannot find Content-Length2,check  httpheader".format(os.getpid())
                sys.exit(105)
            contentlength = rsp[p1 + 16:p2]
            totalsize = headsize + int(contentlength)
            break
        ###########################################
        while True:
            rsp = self.clientSocket.recv(512)
            if len(rsp) == 0:
                print "worker:{0} recv zero2".format(os.getpid())
                sys.exit(103)
            recvbuf += rsp
            rsp = recvbuf
            if len(rsp) >= totalsize:
                break

        self.recvbytes += len(rsp)
        t2 = time.time()
        t3 = t2 - t1
        self.rsponsetime = t3
        # print len(req),len(rsp)
        # print "--------------"
        # print req
        # print rsp
        # print "==========="
        # sys.exit(0)
        return rsp

    def onTimer(self):
        return
        t = "SimpleWorker(%d) onTimer" % (os.getpid())
        self.log(t)

    def onExit(self):
        pid = os.getpid()
        self.report()
        s = self.share_array[self.worker_id]
        s.worker_id = self.worker_id
        s.reqcount = self.reqcount
        s.reqmaxcount = self.reqmaxcount
        s.rspcount = self.rspcount
        s.rspokcount = self.rspokcount
        s.startms = self.startms
        s.endms = current_ms()
        s.sendbytes = self.sendbytes
        s.recvbytes = self.recvbytes
        pass


if __name__ == '__main__':
    print "main process(%d) start" % os.getpid()
    worker_count = WORKER_COUNT
    g_share_array = Array(WorkerData, WorkerData.createWorkerDataList(worker_count))
    worker_interface_array = list()
    for i in xrange(worker_count):
        w = HttpTestWorker(i, g_share_array)
        worker_interface_array.append(w)
    p = MultiProcessWrapper.MultiProcessWrapper()
    p.startAsForver(worker_interface_array)
    print "main process(%d) end" % (os.getpid())
    print "*" * 100
    gatherResult(g_share_array, worker_count)
    sys.exit(0)




长寿梦
关注
专栏目录
《Python全栈开发：Python 多进程模块（multiprocessing）》
yexiangCSDN的专栏
04-02 200
一、多进程模块（multiprocessing） 1.多进程才是真并行 python有一个非常重要的GIL（global interpreter lock，全局解释器锁）。python代码执行由python虚拟机（解释器主循环）来控制。对python虚拟机的访问由GIL控制，GIL保证同一时刻只有一个线程在执行 python虚拟机执行过程： 1、设置GIL 2、切换到一个线程去运行 3、运行，直至完成指定的字节码指令，或者线程主动让出控制 4、将该线程设置为睡眠状态 5、解锁GIL 6、.
python多线程并发及测试框架案例
09-18
总结来说，本文通过实例展示了Python中如何使用多线程实现并发执行，以及如何构建简单的并发测试框架。了解这些知识对于开发高效、可扩展的Python程序至关重要。同时，它也提醒我们在实际编程中要考虑Python的GIL...
python多进程模块_Python模块整理(五)：多进程multiprocessing
weixin_35917052的博客
01-14 121
线程共享全局状态，进程完全独立。线程局限在一个处理器，线程可以发挥多个处理器的资源.没有找到processing模块只找到multiprocessing#!/usr/bin/env pythonfrom multiprocessing import Process,Queueimport timeq=Queue()def f(q):x=q.get()print "Process number %s...
超详细Python教程——并发编程
最新发布
月流霜的专栏
08-11 1140
可以通过消息队列来实现应用程序的解耦合，消息队列相当于是多线程同步队列的扩展版本，不同机器上的应用程序相当于就是线程，而共享的分布式消息队列就是原来程序中的Queue。消息队列（面向消息的中间件）的最流行和最标准化的实现是AMQP（高级消息队列协议），AMQP源于金融行业，提供了排队、路由、可靠传输、安全等功能，最著名的实现包括：Apache的ActiveMQ、RabbitMQ等。下面的代码异步的从5个URL中获取页面并通过正则表达式的命名捕获组提取了网站的标题。对象来获取任务执行的结果。
python的多线程并发测试
weixin_41715954的博客
06-10 3087
import threading import requests import datetime import time “”" detail接口 @THREAD_NUM :线程数 @ONE_WORKER_NUM :每个线程循环数 “”" THREAD_NUM = 20 ONE_WORKER_NUM = 20 SUMTIME = 0.00 SUCCESSCOUNT = 0 def test(): ...
取代Python多进程！伯克利开源分布式框架Ray
cpongo011702
04-13 503
Ray由伯克利开源，是一个用于并行计算和分布式Python开发的开源项目。本文将介绍如何使用Ray轻松构建可从笔记本电脑扩展到大型集群的应用程序。并行和分布式计算是现代应用程序的主要内容。我们需要利用多个核心或多台机器来加速应用程序或大规模运行它们。网络爬虫和搜索所使用的基础设施并不是在某人笔记本电脑上运行的单线程程序，而是相互通信和交互的服务的集合。云计算承诺在所有维度上（内存、计算、存储等）实...
Python 多进程程序框架
Eagle的博客
10-04 689
介绍 python多进程框架用于编写多进程程序 注意 多进程程序报错不会输出, 先用单进程调试完成后才运行 多进程的子进程函数请用单独的类封装, 否者子程序函数不会运行 import os from multiprocessing import Pool,cpu_count import time class MainProgress: def __init__(self): self.fileCount = 1000000 '''初始化多进程池'''
Python并发之多进程的方法实例代码
09-20
在了解Python中的多进程编程前，首先要了解进程与线程这两...以上关于Python多进程编程的核心概念和代码实现示例，覆盖了从进程的基础理论到具体编程实践的大部分重要内容，是学习Python多进程并发编程不可或缺的部分。
Python资源之浏览器自动化与仿真-多进程并发-异步
08-28
在 Python 中，常见的多进程并发技术有： 1. threading：Python 标准库的多线程运行，能够对 I/O 密集型任务进行并发执行。 2. multiprocessing：Python 标准库的多进程执行，能够对 CPU 密集型任务进行并发执行。...
pyndk:python 高性能,高并发，轻量级，多进程，多线程网络开发框架
05-31
python 高性能,高并发，轻量级，多进程，多线程，异步非阻塞网络开发框架。适用linux 下 python 2.6-2.7版本（不能用于windows，因为用了select.epoll ) 4w/qps 单进程，及多进程DEMO from pyndk.CCommMgr import *...
Python-Python3爬虫系列的理论验证比较同步依序下载多进程并发多线程并发和asyncio异步编程之间的效率差别
08-12
本主题将深入探讨Python3中四种不同的并发模型：同步依序下载、多进程（multiprocessing）、多线程（multithreading）以及asyncio异步编程，并通过理论分析和实际案例对比它们之间的效率差异。 1. 同步依序下载： ...
Python-pulsar事件驱动的并发框架
08-10
pulsar：事件驱动的并发框架
python 多线程对post请求服务器测试并发的方法
09-19
今天小编就为大家分享一篇python 多线程对post请求服务器测试并发的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
Python-一个进程级别的python并行框架
08-11
一个进程级别的python并行框架，可用于深度学习调参等任务，可通过 pip install MultiRunner 安装
基于python multiprocessing库的多进程服务框架
qq_25341531的博客
04-12 1240
基于python multiprocessing库的多进程服务框架前言正文功能架构代码注意参考 前言 python由于解析器CPython中GIL（Global Interpreter Lock）的缘故，使得多线程python服务并没有想象中的那么高效率（没有发挥CPU多核的优势），具体原因这边不多做展开（细节可参考《python中的GIL详解》）。 因此，考虑通过使用python multipr...
(python)多进程
marst437730201的博客
08-23 3871
工作中遇到任务较重且耗时相对较长的情况,这时候想起来用多进程处理这类IO 密集型任务.最重要的是,multiprocessing.Pool实在是简单又高效,充分利用了多核CPU同时并行处理多个任务.支持多进程并行处理，可以利用多核 CPU 提高任务的执行效率和速度。提供了简单易用的 API，方便进行任务的分发和结果的收集，代码编写相对简单。可以在一定程度上降低代码复杂度，例如避免手动创建和管理多个进程等。缺点：进程切换开销较大，特别是当进程池中进程数量过多时，容易产生性能瓶颈。
python多进程
AI创世纪的博客
08-31 173
为了克服这些问题，Python提供了多进程模块（multiprocessing），可以使用多个进程来充分利用多核处理器的优势，避免GIL的限制，同时提供更好的隔离性，使得多进程编程在某些情况下比多线程更合适。但是，很多的线上服务内部是可以并行执行的，而且并行的部分是CPU密集型的任务（比如机器学习模型的推理）。5、GIL导致的长时间任务阻塞：如果某个线程在执行一个长时间的任务，由于GIL的存在，其他线程无法执行Python代码，导致整个应用程序的响应性下降。串行执行，且均在单核(cpu1)上执行。
项目框架、Python——生产者/消费者+流水线模式的多进程工作框架
Eyizoha的博客
04-29 1569
简介 开发智能截图系统的时候将系统设计为取帧模块、分析模块、评估模块、截图模块和显示模块的线性串联。每个模块都是独立的进程或进程池，像流水线一样处理画面并转交下一模块，模块之间以队列连接。将这种多个生产者/消费者串联起来协同工作的思想进一步扩展便成了一个项目框架。 代码 头部 import multiprocessing as mp from threading import Thread fro...
python多线程框架_python多线程与多进程异步事件框架
weixin_39620001的博客
11-28 87
from multiprocessing importProcess, QueueclassEventEngine(object):#初始化事件事件驱动引擎def __init__(self):#保存事件列表self.__eventQueue =Queue()#引擎开关self.__active =False#事件处理字典{'event1': [handler1,handler2] , 'even...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值