Android LruCache源码解析

最新推荐文章于 2024-04-30 08:14:34 发布
最新推荐文章于 2024-04-30 08:14:34 发布
阅读量318 收藏 1
点赞数
分类专栏： # Android Glide架构设计 Android 文章标签： android lrucache
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hongxue8888/article/details/100006779
版权

文章目录


参考：

LruCache 源码解析

LruCache源码解析

LruCache 注释源码

LruCache源码解析_效果展示

Android开发中，为了减少用户的流量使用和使APP体验更流畅，我们通常会使用缓存技术。通常来说，缓存分两级。

  • 第一级，是内存缓存，它的好处是，读写非常快，缺点则是，过量地使用会使APP整体变得十分卡顿，因为运行的内存不足了，甚至引起OOM。
  • 第二级，是文件缓存（File,SQLite等），文件缓存的读写效率要低于内存缓存。但是空间更加的充足。

一级缓存由于空间很有限，我们通常会为它设置一个size，当超过这个size时，缓存会将不常用的内容清掉。

Android中提供了一个方便的容器，用来处理这个缓存问题——LruCache

1. 简介

LRU 是 Least Recently Used 最近最少使用算法。

曾经，在各大缓存图片的框架没流行的时候。有一种很常用的内存缓存技术：SoftReference 和 WeakReference（软引用和弱引用）。但是走到了 Android 2.3（Level 9）时代，垃圾回收机制更倾向于回收 SoftReference 或 WeakReference 的对象。后来，又来到了 Android3.0，图片缓存在内容中，因为不知道要在是什么时候释放内存，没有策略，没用一种可以预见的场合去将其释放。这就造成了内存溢出。

2. 使用方法

  1. （必填）你需要提供一个缓存容量作为构造参数。
  2. （必填） 覆写 sizeOf 方法 ，自定义设计一条数据放进来的容量计算，如果不覆写就无法预知数据的容量，不能保证缓存容量限定在最大容量以内。
  3. （选填） 覆写 entryRemoved 方法 ，你可以知道最少使用的缓存被清除时的数据（ evicted, key, oldValue, newVaule ）。
  4. （记住）LruCache是线程安全的，在内部的 get、put、remove 包括 trimToSize 都是安全的（因为都上锁了）。

使用如下：

  	private static final float ONE_MIB = 1024 * 1024;
    // 7MB
    private static final int CACHE_SIZE = (int) (7 * ONE_MIB);
    private LruCache<String, Bitmap> bitmapCache;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        this.bitmapCache = new LruCache<String, Bitmap>(CACHE_SIZE) {
            protected int sizeOf(String key, Bitmap value) {
                return value.getByteCount();
            }

            @Override
            protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
        
            }
        };

    }

3. 源码分析

LruCache 原理概要解析

LruCache 就是 利用 LinkedHashMap 的一个特性（ accessOrder＝true 基于访问顺序 ）再加上对 LinkedHashMap 的数据操作上锁实现的缓存策略。

LruCache 的数据缓存是内存中的。

  1. 首先设置了内部 LinkedHashMap 构造参数 accessOrder=true， 实现了数据排序按照访问顺序。

  2. 然后在每次 LruCache.get(K key) 方法里都会调用 LinkedHashMap.get(Object key)。

  3. 如上述设置了 accessOrder=true 后，每次 LinkedHashMap.get(Object key) 都会进行 LinkedHashMap.afterNodeAccess(Node<K,V> e)。

  4. LinkedHashMap 是双向循环链表，然后每次 LruCache.get -> LinkedHashMap.get 的数据就被放到最末尾了。

  5. 在 put 和 trimToSize 的方法执行下，如果发生数据量移除，会优先移除掉最前面的数据（因为最新访问的数据在尾部）。

主要的成员变量

	//主要的存储成员变量
	private final LinkedHashMap<K, V> map;
  	/**
     * 缓存大小的单位。不规定元素的数量。
     */
    // 已经存储的数据大小
    private int size;
    // 最大存储大小
    private int maxSize;
    // 调用put的次数
    private int putCount;
    // 调用create的次数
    private int createCount;
    // 收回的次数 (如果出现)
    private int evictionCount;
    // 命中的次数（取出数据的成功次数）
    private int hitCount;
    // 丢失的次数（取出数据的丢失次数）
    private int missCount;

LruCache 的唯一构造方法

/**
 * LruCache的构造方法：需要传入最大缓存个数
 */
    public LruCache(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;
     /*
     * 初始化LinkedHashMap
     * 第一个参数：initialCapacity，初始大小
     * 第二个参数：loadFactor，负载因子=0.75f
     * 第三个参数：accessOrder=true，基于访问顺序；accessOrder=false，基于插入顺序
     */
        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
    }

  1. 第一个参数 initialCapacity 用于初始化该 LinkedHashMap 的大小。

  2. 第二个参数 loadFactor，这个其实的 HashMap 里的构造参数，涉及到扩容问题，比如 HashMap 的最大容量是100，那么这里设置0.75f的话，到75容量的时候就会扩容。

  3. 第三个参数 accessOrder=true ，这样的话 LinkedHashMap 数据排序就会基于数据的访问顺序，从而实现了 LruCache 核心工作原理。

LruCache.get(K key)

    /**
     * 根据key查询缓存，如果存在于缓存或者被create方法创建了。
     * 如果值返回了，那么它将被移动到双向循环链表的的尾部。
     * 如果如果没有缓存的值，则返回null。
     */
    public final V get(K key) {
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V mapValue;
        synchronized (this) {
            // LinkHashMap 如果设置按照访问顺序的话，这里每次get都会重整数据顺序
            mapValue = map.get(key);
            // 计算 命中次数
            if (mapValue != null) {
                hitCount++;
                return mapValue;
            }
            // 计算 丢失次数
            missCount++;
        }

        /*
         * 官方解释：
         * 尝试创建一个值，这可能需要很长时间，并且Map可能在create()返回的值时有所不同。如果在create()执行的时
         * 候，一个冲突的值被添加到Map，我们在Map中删除这个值，释放被创造的值。
         */
        V createdValue = create(key);
        if (createdValue == null) {
            return null;
        }

        /***************************
         * 不覆写create方法走不到下面 *
         ***************************/

        /*
         * 正常情况走不到这里
         * 走到这里的话 说明 实现了自定义的 create(K key) 逻辑
         * 因为默认的 create(K key) 逻辑为null
         */
        synchronized (this) {
            // 记录 create 的次数
            createCount++;
            // 将自定义create创建的值，放入LinkedHashMap中，如果key已经存在，会返回 之前相同key 的值
            mapValue = map.put(key, createdValue);

            // 如果之前存在相同key的value，即有冲突。
            if (mapValue != null) {
                /*
                 * 有冲突
                 * 所以 撤销 刚才的 操作
                 * 将 之前相同key 的值 重新放回去
                 */
                map.put(key, mapValue);
            } else {
                // 拿到键值对，计算出在容量中的相对长度，然后加上
                size += safeSizeOf(key, createdValue);
            }
        }

        // 如果上面 判断出了 将要放入的值发生冲突
        if (mapValue != null) {
            /*
             * 刚才create的值被删除了，原来的 之前相同key 的值被重新添加回去了
             * 告诉 自定义 的 entryRemoved 方法
             */
            entryRemoved(false, key, createdValue, mapValue);
            return mapValue;
        } else {
            // 上面 进行了 size += 操作 所以这里要重整长度
            trimToSize(maxSize);
            return createdValue;
        }
    }

LinkedHashMap.get(Object key)

public V get(Object key) {
    Node<K,V> e;
    // 调用 HashMap  get 方法
    if ((e = getNode(hash(key), key)) == null)
        return null;
    // 如果设置了 LRU 策略
    if (accessOrder)
    // 这个方法把当前 key 移动到队尾
        afterNodeAccess(e);
    return e.value;
}

从上述源码中，可以看到，通过 afterNodeAccess 方法把当前访问节点移动到了队尾，其实不仅仅是 get 方法，执行 getOrDefault、compute、computeIfAbsent、computeIfPresent、merge 方法时，也会这么做，通过不断的把经常访问的节点移动到队尾，那么靠近队头的节点，自然就是很少被访问的元素了。

afterNodeAccess方法如下：

	//把当前访问节点移动到了队尾
    void afterNodeAccess(Node<K,V> e) { // move node to last
        LinkedHashMapEntry<K,V> last;
        if (accessOrder && (last = tail) != e) {
            LinkedHashMapEntry<K,V> p =
                (LinkedHashMapEntry<K,V>)e, b = p.before, a = p.after;
            p.after = null;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a != null)
                a.before = b;
            else
                last = b;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }

LinkedHashMap 是双向循环链表，然后此次 LruCache.get -> LinkedHashMap.get 的数据就被放到最末尾了。

以上就是 LruCache 核心工作原理。

双向循环链表图如下所示：
在这里插入图片描述

接下来介绍 LruCache 的容量溢出策略。

LruCache.put(K key, V value)

	/**
     * 给对应key缓存value，该value将被移动到队头。
     */
    public final V put(K key, V value) {
        if (key == null || value == null) {
            throw new NullPointerException("key == null || value == null");
        }

        V previous;
        synchronized (this) {
            // 记录 put 的次数
            putCount++;
            // 拿到键值对，计算出在容量中的相对长度，然后加上
            size += safeSizeOf(key, value);
            /*
             * 放入 key value
             * 如果 之前存在key 则返回 之前key 的value
             * 记录在 previous
             */
            previous = map.put(key, value);
            // 如果存在冲突
            if (previous != null) {
                // 计算出 冲突键值 在容量中的相对长度，然后减去
                size -= safeSizeOf(key, previous);
            }
        }
         // 如果上面发生冲突
        if (previous != null) {
            /*
             * previous值被剔除了，此次添加的 value 已经作为key的 新值
             * 告诉 自定义 的 entryRemoved 方法
             */
            entryRemoved(false, key, previous, value);
        }
        trimToSize(maxSize);
        return previous;
    }

记住几点：

  1. put 开始的时候确实是把值放入 LinkedHashMap 了，不管超不超过你设定的缓存容量。
  2. 然后根据 safeSizeOf 方法计算 此次添加数据的容量是多少，并且加到 size 里 。
  3. 说到 safeSizeOf 就要讲到 sizeOf(K key, V value) 会计算出此次添加数据的大小 。
  4. 直到 put 要结束时，进行了 trimToSize 才判断 size 是否 大于 maxSize 然后进行最近很少访问数据的移除。

LruCache.trimToSize(int maxSize)

public void trimToSize(int maxSize) {
    /*
     * 这是一个死循环，
     * 1.只有 扩容 的情况下能立即跳出
     * 2.非扩容的情况下，map的数据会一个一个删除，直到map里没有值了，就会跳出
     */
    while (true) {
        K key;
        V value;
        synchronized (this) {
            // 在重新调整容量大小前，本身容量就为空的话，会出异常的。
            if (size < 0 || (map.isEmpty() && size != 0)) {
                throw new IllegalStateException(
                        getClass().getName() + ".sizeOf() is reporting inconsistent results!");
            }
            // 如果是 扩容 或者 map为空了，就会中断，因为扩容不会涉及到丢弃数据的情况
            if (size <= maxSize || map.isEmpty()) {
                break;
            }

            Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
            key = toEvict.getKey();
            value = toEvict.getValue();
            map.remove(key);
            // 拿到键值对，计算出在容量中的相对长度，然后减去。
            size -= safeSizeOf(key, value);
            // 添加一次收回次数
            evictionCount++;
        }
        /*
         * 将最后一次删除的最少访问数据回调出去
         */
        entryRemoved(true, key, value, null);
    }
}

简单描述：会判断之前 size 是否大于 maxSize 。是的话，直接跳出后什么也不做。不是的话，证明已经溢出容量了。由于最近经常访问的数据在最末尾。拿到一个存放 key 的 Set，然后一直一直从头开始删除，删一个判断是否溢出，直到没有溢出。

覆写 entryRemoved 的作用

/**
 * 1.当被回收或者删掉时调用。该方法当value被回收释放存储空间时被remove调用
 * 或者替换条目值时put调用，默认实现什么都没做。
 * 2.该方法没用同步调用，如果其他线程访问缓存时，该方法也会执行。
 * 3.evicted=true：如果该条目被删除空间 （表示 进行了trimToSize or remove）  evicted=false：put冲突后 或 get里成功create后
 * 导致
 * 4.newValue!=null，那么则被put()或get()调用。
 */
protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {
}

entryRemoved被LruCache调用的场景：

  1. （put） put 发生 key 冲突时被调用，evicted=false，key=此次 put 的 key，oldValue=被覆盖的冲突 value，newValue=此次 put 的 value。
  2. （trimToSize） trimToSize 的时候，只会被调用一次，就是最后一次被删除的最少访问数据带回来。evicted=true，key=最后一次被删除的 key，oldValue=最后一次被删除的 value，newValue=null（此次没有冲突，只是 remove）。
  3. （remove） remove的时候，存在对应 key，并且被成功删除后被调用。evicted=false，key=此次 put的 key，oldValue=此次删除的 value，newValue=null（此次没有冲突，只是 remove）。
  4. （get后半段，查询丢失后处理情景，不过建议忽略） get 的时候，正常的话不实现自定义 create 的话，代码上看 get 方法只会走一半，如果你实现了自定义的 create(K key) 方法，并且在 你 create 后的值放入 LruCache 中发生 key 冲突时被调用，evicted=false，key=此次 get 的 key，oldValue=被你自定义 create(key)后的 value，newValue=原本存在 map 里的 key-value。

4. 总结

LruCache重要的几点：

  1. LruCache 是通过 LinkedHashMap 构造方法的第三个参数的 accessOrder=true 实现了 LinkedHashMap 的数据排序基于访问顺序 （最近访问的数据会在链表尾部），在容量溢出的时候，将链表头部的数据移除。从而，实现了 LRU 数据缓存机制。

  2. LruCache 在内部的get、put、remove包括 trimToSize 都是安全的（因为都上锁了）。

  3. LruCache 自身并没有释放内存，将 LinkedHashMap 的数据移除了，如果数据还在别的地方被引用了，还是有泄漏问题，还需要手动释放内存。

  4. 覆写 entryRemoved 方法能知道 LruCache 数据移除是是否发生了冲突，也可以去手动释放资源。

  5. maxSize 和 sizeOf(K key, V value) 方法的覆写息息相关，必须相同单位。（ 比如 maxSize 是7MB，自定义的 sizeOf 计算每个数据大小的时候必须能算出与MB之间有联系的单位 ）

傅晨明
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android LruCache 源码分析
吴豪杰
01-18 1112
学过操作系统这门课的朋友都还记得 LRU 这个算法吧，中文名叫”最近最久未使用”，它是用在页面置换策略中的一种很巧妙的淘汰算法，而在 Android 中，也有一个缓存淘汰机制用到了它，叫做 LruCache，它也可以说是一个精妙的设计吧，这篇博文中，笔者将带领大家剖析它源码中的精妙之处…1. 初始化LruCache 类源码位于 android.util.LruCache 包下，大家也可以同
Android LruCache使用分析
xpleemoon
03-26 2082
LRU Cache数据结构的介绍可以参考前面的http://blog.csdn.net/xplee0576/article/details/22200537。 　　本文以Android LRUCache来做一个简单的介绍。我们已经知道LRU Cache是一个hash map+双向链表的数据结构，那么在Android的Java自然也逃不出这个框，谷歌在Android3.1（v4 library
Android源码分析：LruCache 缓存机制实现原理，2024年最新四年Android面试遇到的问题整理
2401_84023710的博客
04-09 625
作为一名从事Android的开发者，很多人最近都在和我吐槽Android是不是快要凉了？而在我看来这正是市场成熟的表现，所有的市场都是温水煮青蛙，永远会淘汰掉不愿意学习改变，安于现状的那批人，希望所有的人能在大浪淘沙中留下来，因为对于市场的逐渐成熟，平凡并不是我们唯一的答案！一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！873240)]
Android LruCache源码分析
xiangxiongfly
02-22 560
LruCache（Least Recently Used Cache，最少最近使用缓存）是 Android 中的一种缓存机制。 根据数据的使用频率淘汰减少使用的数据，当需要缓存新数据时，如果缓存已满，LruCache 会淘汰最近最少使用的数据，腾出空间给新数据。
Android源码分析：LruCache 缓存机制实现原理
最新发布
2401_84538612的博客
04-30 974
我见过很多技术leader在面试的时候，遇到处于迷茫期的大龄程序员，比面试官年龄都大。这些人有一些共同特征：可能工作了5、6年，还是每天重复给业务部门写代码，工作内容的重复性比较高，没有什么技术含量的工作。问到这些人的职业规划时，他们也没有太多想法。其实30岁到40岁是一个人职业发展的黄金阶段，一定要在业务范围内的扩张，技术广度和深度提升上有自己的计划，才有助于在职业发展上有持续的发展路径，而不至于停滞不前。不断奔跑，你就知道学习的意义所在！
Android | 内存缓存LruCache使用及其源码解析
小马快跑的博客
07-17 1032
LruCache 作为内存缓存，使用强引用方式缓存有限个数据，当缓存的某个数据被访问时，它就会被移动到队列的头部，当一个新数据要添加到LruCache而此时缓存大小要满时，队尾的数据就有可能会被垃圾回收器(GC)回收掉，LruCache使用的LRU(Least Recently Used)算法，即：把最近最少使用的数据从队列中移除，把内存分配给最新进入的数据。 如果LruCache缓存的某条数据明确
Android LruCache源码详解
数据结构和算法
04-20 1684
尊重原创，转载请标明出处http://blog.csdn.net/abcdef314159 之前的两篇我们详细分析了HashMap和LinkedHashMap，就是为了讲解LruCache做铺垫的，这一篇我们来分析一下Android中常用的缓存类LruCache，我们知道Android中的优化比较多，其中就有一个关于图片缓存的问题，如果处理不好很有可能会出现ANR。在讲解之前我们最好...
Android缓存机制——LruCache
qq_16927853的博客
11-04 463
Android缓存机制——LruCache Android的三级缓存，其中主要的就是内存缓存和硬盘缓存。这两种缓存机制的实现都应用到了LruCache算法，下面我们就从使用到源码解析，来彻底理解Android中的缓存机制。 LruCache 介绍 LruCache 顾名思义就是使用LRU缓存策略的缓存，那么LRU是什么呢? 最近最少使用到的（least recently used），就是当超出...
几个比较好的Android项目源码
09-02
在Android开发领域，掌握高质量的项目源码是提升技能、理解最佳实践的重要途径。这个压缩包文件名为"几个比较好的Android项目源码"，显然包含了若干精选的Android应用源代码，旨在帮助开发者尤其是进阶者深入学习和...
详解Android的内存优化--LruCache
08-31
**LruCache 源码解析** 1. **初始化** `LruCache` 构造函数接收一个整型参数 `maxSize`，表示缓存的最大容量。它创建了一个 `LinkedHashMap`，并设置了三个参数：初始容量为 0，负载因子为 0.75（即当达到 75% ...
Android图片加载利器之Picasso源码解析
08-31
Android图片加载利器之Picasso源码解析 Android图片加载利器之Picasso源码解析主要为大家详细解析了Android图片加载利器之Picasso源码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下。 Picasso是 Android ...
基于LRU算法源代码
01-15
（1） LRU：内存管理的一种页面置换算法，对于在内存中但又不用的数据块（内存块）叫做LRU，操作系统会根据哪些数据属于LRU而将其移出内存而腾出空间来加载另外的数据。 （2） LRU算法：LRU是Least Recently Used的缩写，即最近最少使用，常用于页面置换算法，是为虚拟页式存储管理服务的。 优点：在内存有限的情况下，扩展一部分外存作为虚拟内存，真正的内存只存储当前运行时所用得到信息。这无疑极大地扩充了内存的功能，极大地提高了计算机的并发度。 缺点：运行时间变长这一缺点：进程运行过程中，不可避免地要把在外存中存放的一些信息和内存中已有的进行交换，由于外存的低速，这一步骤所花费的时间不可忽略。
Android 网易客户端源码.zip
07-19
3. **数据解析**：JSON格式是常见的数据交换格式，源码中可能会包含对JSON的解析，如使用Gson或Jackson库。理解如何将接收到的JSON数据转化为Java对象，有助于数据处理和展示。 4. **用户界面**：Android Studio中...
Android应用源码BitmapFunc.zip
12-04
decode*方法可以根据不同的源解析出Bitmap，例如decodeResource()用于从资源文件加载，decodeFile()用于从本地文件加载。 3. **内存管理与优化**：Bitmap占用了大量内存，不当使用可能导致内存溢出。使用...
杂谈（Lrucache机制）
qq_34501274的博客
05-21 258
简介 LruCache是Android 3.1所提供的一个缓存类，目前主流的图片加载框架底层大部分都是基于它。 LruCache内部维护了一个LinkedHashMap，利用LinkedHashMap的数据结构特点去实现最近很少使用这一算法进行缓存。 LinkedHashMap介绍 LinkedHashMap的数据结构：数组+双向链表 特点：双向链表结构可以控制访问顺序和插入顺序，使得Linked...
Android LruCache
mChenys的博客
09-23 1977
当调用put()方法时，就会在集合中添加元素，并调用trimToSize()判断缓存是否已满，如果满了就用LinkedHashMap的迭代器删除队首元素，即近期最少访问的元素。当调用LruCache的get()方法获取集合中的缓存对象时，就代表访问了一次该元素，将会更新队列，保持整个队列是按照访问顺序排序。有以上结果可以看出，这个设置为true时，如果对一个元素进行了操作(put,get)，就会把那个元素放到集合的最后，设置为false时，无论怎么操作，集合元素的顺序都是按照插入的顺序来进行存储的。
Android 缓存浅谈（一） LruCache
热门推荐
zhangxiaowei
08-11 1万+
Android应用开发好多场景都是手机和web服务器之间进行通信，从服务端需要获取数据，但是当访问的数据比较大，比较多，并且是重复数据时，会极大影响性能，甚至应用崩溃，手机卡死，这时候就要考虑缓存机制了！Android中可通过缓存来减少频繁的网络操作，减少流量、提升性能。     在实际开发中，缓存机制使用最频繁的便是图片缓存！目前大部分的App都是图文结合，从web服务器获取文字和图片，文字显
Android LruCache源码简析
笨鸟的专栏
03-31 230
LruCache源码解析 缓存置换算法：LRU，LFU，FIFO LRU：淘汰最长时间未使用的对象LFU：淘汰一段时间内使用最少的对象，也就是淘汰使用频率最低的对象  FIFO：frist in first out，先进先出 源码解析 LruCache是线程安全的，对maxSize、map的操作，都有用synchronized package android.support.v4.ut...
android launcher源码解析
09-28
综上所述，Android Launcher源码解析涉及多个组件和类，需要了解Android应用程序交互的核心概念，同时需要关注性能优化和用户体验。这个过程可以帮助开发者深入理解和定制Android系统的启动器。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值