计时服务-计时器（Client）

最新推荐文章于 2023-03-24 11:35:15 发布
最新推荐文章于 2023-03-24 11:35:15 发布
阅读量186 收藏 1
点赞数
分类专栏： Unity 3D
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhanxxiao/article/details/108837146
版权 
//==========================
// - FileName:      PETimer.cs         
// - Created:       true.	
// - CreateTime:    2020/08/07 02:40:30	
// - Email:         1670328571@qq.com		
// - Region:        China WUHAN	
// - Description:   计时器
//==========================
using System;
using System.Collections.Generic;
using System.Timers;

public class PETimer
{
    private Action<string> taskLog;
    private Action<Action<int>, int> taskHandle;
    private static readonly string lockTid = "lockTid";
    private DateTime startDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0);
    private double nowTime;
    private Timer srvTimer;
    private int tid;
    private List<int> tidLst = new List<int>();
    private List<int> recTidLst = new List<int>();

    private static readonly string lockTime = "lockTime";
    private List<PETimeTask> tmpTimeLst = new List<PETimeTask>();
    private List<PETimeTask> taskTimeLst = new List<PETimeTask>();
    private List<int> tmpDelTimeLst = new List<int>();

    private int frameCounter;

    private static readonly string lockFrame = "lockFrame";
    private List<PEFrameTask> tmpFrameLst = new List<PEFrameTask>();
    private List<PEFrameTask> taskFrameLst = new List<PEFrameTask>();
    private List<int> tmpDelFrameLst = new List<int>();

    public PETimer(int interval = 0)
    {
        tidLst.Clear();
        recTidLst.Clear();

        tmpTimeLst.Clear();
        taskTimeLst.Clear();

        tmpFrameLst.Clear();
        taskFrameLst.Clear();

        if (interval != 0)
        {
            srvTimer = new Timer(interval)
            {
                AutoReset = true
            };

            srvTimer.Elapsed += (object sender, ElapsedEventArgs args) => {
                Update();
            };
            srvTimer.Start();
        }
    }

    public void Update()
    {
        CheckTimeTask();
        CheckFrameTask();

        DelTimeTask();
        DelFrameTask();

        if (recTidLst.Count > 0)
        {
            lock (lockTid)
            {
                RecycleTid();
            }
        }
    }
    private void DelTimeTask()
    {
        if (tmpDelTimeLst.Count > 0)
        {
            lock (lockTime)
            {
                for (int i = 0; i < tmpDelTimeLst.Count; i++)
                {
                    bool isDel = false;
                    int delTid = tmpDelTimeLst[i];
                    for (int j = 0; j < taskTimeLst.Count; j++)
                    {
                        PETimeTask task = taskTimeLst[j];
                        if (task.tid == delTid)
                        {
                            isDel = true;
                            taskTimeLst.RemoveAt(j);
                            recTidLst.Add(delTid);
                            //LogInfo("Del taskTimeLst ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
                            break;
                        }
                    }

                    if (isDel)
                        continue;

                    for (int j = 0; j < tmpTimeLst.Count; j++)
                    {
                        PETimeTask task = tmpTimeLst[j];
                        if (task.tid == delTid)
                        {
                            tmpTimeLst.RemoveAt(j);
                            recTidLst.Add(delTid);
                            //LogInfo("Del tmpTimeLst ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
                            break;
                        }
                    }
                }
            }
        }
    }
    private void DelFrameTask()
    {
        if (tmpDelFrameLst.Count > 0)
        {
            lock (lockFrame)
            {
                for (int i = 0; i < tmpDelFrameLst.Count; i++)
                {
                    bool isDel = false;
                    int delTid = tmpDelFrameLst[i];
                    for (int j = 0; j < taskFrameLst.Count; j++)
                    {
                        PEFrameTask task = taskFrameLst[j];
                        if (task.tid == delTid)
                        {
                            isDel = true;
                            taskFrameLst.RemoveAt(j);
                            recTidLst.Add(delTid);
                            break;
                        }
                    }
                    if (isDel)
                        continue;
                    for (int j = 0; j < tmpFrameLst.Count; j++)
                    {
                        PEFrameTask task = tmpFrameLst[j];
                        if (task.tid == delTid)
                        {
                            tmpFrameLst.RemoveAt(j);
                            recTidLst.Add(delTid);
                            break;
                        }
                    }
                }
            }
        }
    }
    private void CheckTimeTask()
    {
        if (tmpTimeLst.Count > 0)
        {
            lock (lockTime)
            {
                //加入缓存区中的定时任务
                for (int tmpIndex = 0; tmpIndex < tmpTimeLst.Count; tmpIndex++)
                {
                    taskTimeLst.Add(tmpTimeLst[tmpIndex]);
                }
                tmpTimeLst.Clear();
            }
        }

        //遍历检测任务是否达到条件
        nowTime = GetUTCMilliseconds();
        for (int index = 0; index < taskTimeLst.Count; index++)
        {
            PETimeTask task = taskTimeLst[index];
            if (nowTime.CompareTo(task.destTime) < 0)
            {
                continue;
            }
            else
            {
                Action<int> cb = task.callback;
                try
                {
                    if (taskHandle != null)
                    {
                        taskHandle(cb, task.tid);
                    }
                    else
                    {
                        if (cb != null)
                        {
                            cb(task.tid);
                        }
                    }
                }
                catch (Exception e)
                {
                    LogInfo(e.ToString());
                }

                //移除已经完成的任务
                if (task.count == 1)
                {
                    taskTimeLst.RemoveAt(index);
                    index--;
                    recTidLst.Add(task.tid);
                }
                else
                {
                    if (task.count != 0)
                    {
                        task.count -= 1;
                    }
                    task.destTime += task.delay;
                }
            }
        }
    }
    private void CheckFrameTask()
    {
        if (tmpFrameLst.Count > 0)
        {
            lock (lockFrame)
            {
                //加入缓存区中的定时任务
                for (int tmpIndex = 0; tmpIndex < tmpFrameLst.Count; tmpIndex++)
                {
                    taskFrameLst.Add(tmpFrameLst[tmpIndex]);
                }
                tmpFrameLst.Clear();
            }
        }

        frameCounter += 1;
        //遍历检测任务是否达到条件
        for (int index = 0; index < taskFrameLst.Count; index++)
        {
            PEFrameTask task = taskFrameLst[index];
            if (frameCounter < task.destFrame)
            {
                continue;
            }
            else
            {
                Action<int> cb = task.callback;
                try
                {
                    if (taskHandle != null)
                    {
                        taskHandle(cb, task.tid);
                    }
                    else
                    {
                        if (cb != null)
                        {
                            cb(task.tid);
                        }
                    }
                }
                catch (Exception e)
                {
                    LogInfo(e.ToString());
                }

                //移除已经完成的任务
                if (task.count == 1)
                {
                    taskFrameLst.RemoveAt(index);
                    index--;
                    recTidLst.Add(task.tid);
                }
                else
                {
                    if (task.count != 0)
                    {
                        task.count -= 1;
                    }
                    task.destFrame += task.delay;
                }
            }
        }
    }

    #region TimeTask
    public int AddTimeTask(Action<int> callback, double delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1)
    {
        if (timeUnit != PETimeUnit.Millisecond)
        {
            switch (timeUnit)
            {
                case PETimeUnit.Second:
                    delay = delay * 1000;
                    break;
                case PETimeUnit.Minute:
                    delay = delay * 1000 * 60;
                    break;
                case PETimeUnit.Hour:
                    delay = delay * 1000 * 60 * 60;
                    break;
                case PETimeUnit.Day:
                    delay = delay * 1000 * 60 * 60 * 24;
                    break;
                default:
                    LogInfo("Add Task TimeUnit Type Error...");
                    break;
            }
        }
        int tid = GetTid(); ;
        nowTime = GetUTCMilliseconds();
        lock (lockTime)
        {
            tmpTimeLst.Add(new PETimeTask(tid, callback, nowTime + delay, delay, count));
        }
        return tid;
    }
    public void DeleteTimeTask(int tid)
    {
        lock (lockTime)
        {
            tmpDelTimeLst.Add(tid);
            //LogInfo("TmpDel ID:" + System.Threading.Thread.CurrentThread.ManagedThreadId.ToString());
        }
        /*
         bool exist = false;

         for (int i = 0; i < taskTimeLst.Count; i++) {
             PETimeTask task = taskTimeLst[i];
             if (task.tid == tid) {
                 //taskTimeLst.RemoveAt(i);
                 for (int j = 0; j < tidLst.Count; j++) {
                     if (tidLst[j] == tid) {
                         //tidLst.RemoveAt(j);
                         break;
                     }
                 }
                 exist = true;
                 break;
             }
         }

         if (!exist) {
             for (int i = 0; i < tmpTimeLst.Count; i++) {
                 PETimeTask task = tmpTimeLst[i];
                 if (task.tid == tid) {
                     //tmpTimeLst.RemoveAt(i);
                     for (int j = 0; j < tidLst.Count; j++) {
                         if (tidLst[j] == tid) {
                             //tidLst.RemoveAt(j);
                             break;
                         }
                     }
                     exist = true;
                     break;
                 }
             }
         }

         return exist;
         */
    }
    public bool ReplaceTimeTask(int tid, Action<int> callback, float delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1)
    {
        if (timeUnit != PETimeUnit.Millisecond)
        {
            switch (timeUnit)
            {
                case PETimeUnit.Second:
                    delay = delay * 1000;
                    break;
                case PETimeUnit.Minute:
                    delay = delay * 1000 * 60;
                    break;
                case PETimeUnit.Hour:
                    delay = delay * 1000 * 60 * 60;
                    break;
                case PETimeUnit.Day:
                    delay = delay * 1000 * 60 * 60 * 24;
                    break;
                default:
                    LogInfo("Replace Task TimeUnit Type Error...");
                    break;
            }
        }
        nowTime = GetUTCMilliseconds();
        PETimeTask newTask = new PETimeTask(tid, callback, nowTime + delay, delay, count);

        bool isRep = false;
        for (int i = 0; i < taskTimeLst.Count; i++)
        {
            if (taskTimeLst[i].tid == tid)
            {
                taskTimeLst[i] = newTask;
                isRep = true;
                break;
            }
        }

        if (!isRep)
        {
            for (int i = 0; i < tmpTimeLst.Count; i++)
            {
                if (tmpTimeLst[i].tid == tid)
                {
                    tmpTimeLst[i] = newTask;
                    isRep = true;
                    break;
                }
            }
        }

        return isRep;
    }
    #endregion

    #region FrameTask
    public int AddFrameTask(Action<int> callback, int delay, int count = 1)
    {
        int tid = GetTid();
        lock (lockTime)
        {
            tmpFrameLst.Add(new PEFrameTask(tid, callback, frameCounter + delay, delay, count));
        }
        return tid;
    }
    public void DeleteFrameTask(int tid)
    {
        lock (lockFrame)
        {
            tmpDelFrameLst.Add(tid);
        }
        /*
        bool exist = false;

        for (int i = 0; i < taskFrameLst.Count; i++) {
            PEFrameTask task = taskFrameLst[i];
            if (task.tid == tid) {
                //taskFrameLst.RemoveAt(i);
                for (int j = 0; j < tidLst.Count; j++) {
                    if (tidLst[j] == tid) {
                        //tidLst.RemoveAt(j);
                        break;
                    }
                }
                exist = true;
                break;
            }
        }

        if (!exist) {
            for (int i = 0; i < tmpFrameLst.Count; i++) {
                PEFrameTask task = tmpFrameLst[i];
                if (task.tid == tid) {
                    //tmpFrameLst.RemoveAt(i);
                    for (int j = 0; j < tidLst.Count; j++) {
                        if (tidLst[j] == tid) {
                            //tidLst.RemoveAt(j);
                            break;
                        }
                    }
                    exist = true;
                    break;
                }
            }
        }

        return exist;
        */
    }
    public bool ReplaceFrameTask(int tid, Action<int> callback, int delay, int count = 1)
    {
        PEFrameTask newTask = new PEFrameTask(tid, callback, frameCounter + delay, delay, count);

        bool isRep = false;
        for (int i = 0; i < taskFrameLst.Count; i++)
        {
            if (taskFrameLst[i].tid == tid)
            {
                taskFrameLst[i] = newTask;
                isRep = true;
                break;
            }
        }

        if (!isRep)
        {
            for (int i = 0; i < tmpFrameLst.Count; i++)
            {
                if (tmpFrameLst[i].tid == tid)
                {
                    tmpFrameLst[i] = newTask;
                    isRep = true;
                    break;
                }
            }
        }

        return isRep;
    }
    #endregion

    public void SetLog(Action<string> log)
    {
        taskLog = log;
    }
    public void SetHandle(Action<Action<int>, int> handle)
    {
        taskHandle = handle;
    }

    public void Reset()
    {
        tid = 0;
        tidLst.Clear();
        recTidLst.Clear();

        tmpTimeLst.Clear();
        taskTimeLst.Clear();

        tmpFrameLst.Clear();
        taskFrameLst.Clear();

        taskLog = null;
        srvTimer.Stop();
    }

    public int GetYear()
    {
        return GetLocalDateTime().Year;
    }
    public int GetMonth()
    {
        return GetLocalDateTime().Month;
    }
    public int GetDay()
    {
        return GetLocalDateTime().Day;
    }
    public int GetWeek()
    {
        return (int)GetLocalDateTime().DayOfWeek;
    }
    public DateTime GetLocalDateTime()
    {
        DateTime dt = TimeZone.CurrentTimeZone.ToLocalTime(startDateTime.AddMilliseconds(nowTime));
        return dt;
    }
    public double GetMillisecondsTime()
    {
        return nowTime;
    }
    public string GetLocalTimeStr()
    {
        DateTime dt = GetLocalDateTime();
        string str = GetTimeStr(dt.Hour) + ":" + GetTimeStr(dt.Minute) + ":" + GetTimeStr(dt.Second);
        return str;
    }

    #region Tool Methonds
    private int GetTid()
    {
        lock (lockTid)
        {
            tid += 1;

            //安全代码，以防万一
            while (true)
            {
                if (tid == int.MaxValue)
                {
                    tid = 0;
                }

                bool used = false;
                for (int i = 0; i < tidLst.Count; i++)
                {
                    if (tid == tidLst[i])
                    {
                        used = true;
                        break;
                    }
                }
                if (!used)
                {
                    tidLst.Add(tid);
                    break;
                }
                else
                {
                    tid += 1;
                }
            }
        }

        return tid;
    }
    private void RecycleTid()
    {
        for (int i = 0; i < recTidLst.Count; i++)
        {
            int tid = recTidLst[i];

            for (int j = 0; j < tidLst.Count; j++)
            {
                if (tidLst[j] == tid)
                {
                    tidLst.RemoveAt(j);
                    break;
                }
            }
        }
        recTidLst.Clear();
    }
    private void LogInfo(string info)
    {
        if (taskLog != null)
        {
            taskLog(info);
        }
    }
    private double GetUTCMilliseconds()
    {
        TimeSpan ts = DateTime.UtcNow - startDateTime;
        return ts.TotalMilliseconds;
    }
    private string GetTimeStr(int time)
    {
        if (time < 10)
        {
            return "0" + time;
        }
        else
        {
            return time.ToString();
        }
    }
    #endregion

    class PETimeTask
    {
        public int tid;
        public Action<int> callback;
        public double destTime;//单位：毫秒
        public double delay;
        public int count;

        public PETimeTask(int tid, Action<int> callback, double destTime, double delay, int count)
        {
            this.tid = tid;
            this.callback = callback;
            this.destTime = destTime;
            this.delay = delay;
            this.count = count;
        }
    }

    class PEFrameTask
    {
        public int tid;
        public Action<int> callback;
        public int destFrame;
        public int delay;
        public int count;

        public PEFrameTask(int tid, Action<int> callback, int destFrame, int delay, int count)
        {
            this.tid = tid;
            this.callback = callback;
            this.destFrame = destFrame;
            this.delay = delay;
            this.count = count;
        }
    }
}

public enum PETimeUnit
{
    Millisecond,
    Second,
    Minute,
    Hour,
    Day
}

//==========================
// - FileName:      TimerSvc.cs         
// - Created:       true.	
// - CreateTime:    2020/08/24 02:47:57	
// - Email:         1670328571@qq.com		
// - Region:        China WUHAN	
// - Description:   计时服务
//==========================
using System;

public class TimerSvc : SystemRoot
{
    public static TimerSvc Instance = null;
    private PETimer pt;

    public void InitSvc()
    {
        Instance = this;
        pt = new PETimer();
        //设置日志输出    
        pt.SetLog((string info) =>
        {
            PECommon.Log(info);
        });
        PECommon.Log("Init TimerSvc...");
    }


    public void Update()
    {
        pt.Update();
    }

    public int AddTimeTask(Action<int> callback, double delay, PETimeUnit timeUnit = PETimeUnit.Millisecond, int count = 1)
    {
        return pt.AddTimeTask(callback, delay, timeUnit, count);
    }
}
true...
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android使用service控制计时,如何在android应用中利用service实现一个计时器功能
weixin_28730927的博客
05-27 1103
如何在android应用中利用service实现一个计时器功能发布时间：2020-12-05 17:00:47来源：亿速云阅读：146作者：Leah本篇文章给大家分享的是有关如何在android应用中利用service实现一个计时器功能，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。1、首先建立主页面的设计：activity_time....
prometheus-client:Prometheus的Java客户端
05-19
这不是官方的Prometheus客户端，可以在这里找到： : 目录高级用法测量概括直方图计时器 背景当我们开始迁移到Prometheus时，需要标签的支持-因此我们去检查了官方客户。 在Outbrain，度量标准在我们所有的微服务和...
分布式服务器框架之Server.Common库中实现 秒级定时器
qq_33531923的博客
10-15 387
定时器模块是服务器中的常用组件，本文带你实现一个具有基本功能的定时器模块要想设计一个定时器模块，一般包含两部分，一个是定时器对象（ServerTimer），另一个管理定时器对象的管理者（TimerManager）也叫定时器容器;定时器使用了C#内System库里面的Timer定时器作为定时器的主驱动
webserver-定时器处理非活动连接
最新发布
weixin_44654302的博客
03-24 477
webserver-定时器处理处理非活动连接
Android统一管理Timer计时器Service工具
埋头苦干程序猿
11-09 1874
通过服务保护计时器放置后台不被系统GC。防止计时器失效，并实现注册统一分发处理计时器回调更新UI页面数据。
安卓开发——服务应用，计时器的实现（线程+服务）
weixin_44732379的博客
11-07 2535
目录实验题目实验一代码：布局文件:实验二代码：布局文件： 实验题目 实现一个倒计时时钟，创建子线实现计时功能，使用异步消息机制将计时结果显示在界面上，如图，在文本框中输入数字（使用Number文本框），点击开始按钮后，下方文本框的数字每秒减1，点击停止即停止倒计时 创建ClockActivity，可输入一个时间（使用Time文本框），再创建一个ClockService在用于计时，到时间后，以在Activity中发出通知（在下方的TextView中显示“时间到”）。 注意：这里涉及到了Service操作Ac
io-timers:带Redis的计时器
03-18
io-timers 如何使用 const IoTimers = require ( 'io-timers' ) ; const ioTimers = IoTimers... pubClient ：可选，redis客户端，用于在以下位置发布事件 subClient ：可选，redis客户端用于订阅以下事件： 如果决定提
funny-quiz-client
03-14
项目中的"funny-quiz-client-main"很可能包含以下几个关键部分： 1. **HTML结构**：HTML（超文本标记语言）是网页的基础框架，定义了页面的结构和内容。在"funny-quiz-client"中，HTML文件可能会包含测验问题的布局...
efm-statistics-client
02-09
在"efm-statistics-client-development"目录下，我们可以找到关于这个库的开发资料，包括源代码、构建脚本、文档等。开发者可以通过阅读源代码了解其实现原理，研究如何在自己的项目中集成和使用。构建脚本（通常是...
ASP.NET里面的计时器（相当于控件）
12-23
ASP.NET中的计时器控件（Timer Control）是Web开发中的一个重要组件，它允许开发者创建基于时间的交互式Web应用程序。计时器控件并不直接触发服务器端的事件，而是通过引发客户端的JavaScript事件来实现定时操作。在...
Android Service 与 定时器
07-30
Android 采用service与定时器每隔3秒打印一次log，希望大家能自己扩展，只是简单用法，具体扩展还得靠自己哈。
服务端定时器技术理解（一）
lyt_dawang的博客
03-28 445
服务端在一下业务场景下，需要用到定时器 1.⼼跳检测 2.技能冷却 3.武器冷却 4.倒计时 5.其它需要使⽤超时机制的功能 对于服务端来说，驱动服务端逻辑的事件主要有两个，一个是网络事件，另一个是时间事件。对这两种事件的处理有两种方式： 1.在主线程处理网络事件时，处理时间事件，例如ngnix,redis 2.网络事件和时间事件在不同的线程中处理,例如，skynet 第一种模式示例代码如下： while (!quit) { int now = get_now_.
计时器2（service）
晚风725的博客
07-06 430
package com.example.administrator.exp5; import android.annotation.TargetApi; import android.app.Activity; import android.content.Intent; import android.icu.text.NumberFormat; import android.os.Build;...
Service中进行倒计时
yang1164851882的博客
06-24 1745
前言：本文是关于一个发送验证码倒计时60s，退出验证码填写界面后，60s倒计时结束之前，再次进入倒计时页面，倒计时不会重新开始。鉴于这个功能可能比较常见，需要的可以直接粘过去。 下来介绍我的实现过程：开启一个service进行倒计时，把时间通过广播发送到活动中进行相应操作，就这么点。 一、创建一个service，里面进行倒计时，并实时发送广播： public class CountDown...
android使用service控制计时,android利用service完成计时功能
weixin_35171513的博客
05-27 626
本文为大家分享了android service计时功能的具体代码，供大家参考，具体内容如下1、首先建立主页面的设计：activity_time.xmlandroid:id="@+id/self_driving_wait_ll"android:layout_width="match_parent"android:layout_height="match_parent">android:layo...
Java 获取当前时间及实现时间倒计时功能
weixin_33701294的博客
05-27 1788
引言 在一些项目中或是一些特殊的业务场景中，需要用到显示系统的当前时间，以及一些固定的时间倒计时，时间到后做一些什么事情的业务。接下来咱们就具体看看代码是怎么实现的： <%@ page language="java" contentType="text/html; charset=utf-8" pageEncoding="utf-8"%><!DOC...
linux localtime 线程安全,LocalDate、LocalTime、LocalDateTime常用方法介绍（线程安全）...
weixin_39930557的博客
05-07 708
一、JDK Release Notes：https://www.oracle.com/technetwork/java/javase/jdk-relnotes-index-2162236.html?ssSourceSiteId=otncnhttps://docs.oracle.com/javase/9/docs/api/java/time/package-summary.html二、API Spe...
Java 8新增Java.time包下常用的日期类LocalDate、LocalTime、LocalDateTime、DateFormatter详解
糖果墙的博客
05-14 1568
详细描述测试见代码 package top.jacktgq.demo2; import java.sql.Timestamp; import java.time.DayOfWeek; import java.time.Instant; import java.time.LocalDate; import java.time.LocalDateTime; import java.time.LocalTime; import java.time.Month; import java.time.MonthDay
工作总结之-----WebService计时器如何叫醒
码海拾贝
11-14 1436
前序         工作中往往会用到计时器，此篇中我们关注计时器的失效。由于在项目中webservice的负担较轻，因此决定把计时器放入Web服务中。 实现         在web服务中放入一个任务类，其中放入一个计时器。在类初始化方法中启动计时器。另外放一个持久类，类中专门放置一个静态任务对象。         最后，在Global.asax.cs文件中的Application_St
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值