总结JAVA中的锁

最新推荐文章于 2023-07-07 11:58:10 发布
最新推荐文章于 2023-07-07 11:58:10 发布
阅读量238 收藏 1
点赞数
分类专栏： 多线程 JAVA 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bug_null/article/details/116041698
版权

总结JAVA中各种锁的使用

1. 为什么要使用锁?

​ 拿个生活中的示例来说明这个问题吧，某超市做促销，菜仔油半价卖，35块钱一桶。这消息一出必然会有很多的人抢购。但菜仔油不是无限供应的，超市通常会把菜仔油放到一个地方，每次放进去一个或者两个人。这些人先购结束了，再放下一波人，直到油卖光了，就结束了。

类比卖超市，想像下单程序是不是也是这样子呢，我们的客户通过网页或者手机下单商品。服务器在收到请求后都需要进行扣减库存操作。当非常多的客户同时下单了某一个商品。这样导致大量的请求都需要去扣库存。这时候我们通常就需要进行加锁操作。以将并行的请求变为串行，以防止商品越卖的情况。

2. 锁的演变

单体应用我们可以使用java提供的并发处理相关的API进行控制。但是随着我们需要服务越来越多的客户。已经无法再使用单体应用去服务我们现在的互联网的用户了，现在架构都在从单体应用架构演变为分布式微服务架构。跨JVM或者 跨进程的实例部署，就没有通过java的锁机制来控制并发了。 为了解决这种跨JVM并发访问控制的问题，就需要一种跨JVM的互斥机制，来控制共享资源的访问。这时候就需要引入分布式锁。

那将这些演示的中出现的锁进行总结。可以归纳为这样几类：

在这里插入图片描述

3. 锁的分类

锁一般分为两类：乐观锁与悲观锁。

乐观锁，这是一种积极向上的心态，类比现实就是这个世界还是好人多，所以乐观锁并不会去加锁，在更新数据时做下数据的验证。

悲观锁。这个就是相对乐观锁来说就是另外一种心态了，总是假设最坏的情况，每次操作数据别人都有可能会改变，所以在操作资源前需要获取锁，然后进行操作，操作完了，再释放锁，别人就可以获取到锁，操作资源了。

那什么场景适用乐观锁，什么场景又适用于悲观锁呢？

如果一个应用是读多写入，这类就适合乐观锁。

如果一个应用是写多读少，这类就适合悲观锁。

在这里插入图片描述

4.不加锁的问题

这是一个商量下单的示例。Goods为商品服务，Orders为订单服务，每个订单去扣减一笔库存，这样一个简单的示例。

当出现并发下订单，程序还能正常将库存扣减成功吗？

商品信息Goods

public class Goods {

  /** 商品名称 */
  private String name;

  /** 商品库存数量 */
  private int goodsNum;

  public Goods(String name, int goodsNum) {
    this.name = name;
    this.goodsNum = goodsNum;
  }

  /** 商品的库存扣减操作 */
  public void minusGoods(int num) {
    goodsNum -= num;
  }

  /**
   * 检查是否足够下单
   *
   * @return false，当前商品已经不足已下单 true 当前库在意可以下单
   */
  public boolean sellOut(int nums) {
    if (goodsNum >= nums) {
      return true;
    }
    return false;
  }

  /**
   * 获取商品数量
   *
   * @return 当前商品的数量
   */
  public int getGoods() {
    return goodsNum;
  }
}

订单服务Orders

public class Orders {

  /** 商品服务 */
  private Goods goods;

  public Orders(Goods goods) {
    this.goods = goods;
  }

  /**
   * 创建订单
   *
   * @return
   */
  public boolean createOrder(int num) {

    // 执行商品的减库存操作
    if (goods.sellOut(num)) {
      // 执行扣减库存操作
      goods.minusGoods(num);
      return true;
    }
    return false;
  }

  public int getGoods() {
    return goods.getGoods();
  }
}

执行测试:

public class TestOrders {

  @Test
  public void useOrder() throws InterruptedException {
    int orderNumSum = 800;
    Goods goods = new Goods("mac", orderNumSum);

    // 并发进行下单操作
    int maxOrder = 8;

    int count = 0;
    for (int i = 0; i < orderNumSum / maxOrder; i++) {
      CountDownLatch startLatch = new CountDownLatch(maxOrder);
      for (int j = 0; j < maxOrder; j++) {
        TaskThreadPool.INSTANCE.submit(
            () -> {
              startLatch.countDown();

              Orders instance = new Orders(goods);
              instance.createOrder(1);
            });

        count++;
      }
      // 确保任务都已经开始并行运行
      try {
        startLatch.await();
      } catch (InterruptedException e) {
        e.printStackTrace();
      }
    }
    System.out.println("结束,共运行:" + count + "次");

    TaskThreadPool.INSTANCE.shutdown();

    Thread.sleep(500);

    System.out.println("shutdown status:" + TaskThreadPool.INSTANCE.getPool().isShutdown());

    System.out.println("最后商品的库存:" + goods.getGoods());
  }
}

我们可以多次运行看到结果的输出:

结束,共运行:800次
shutdown status:true
最后商品的数量:3

结束,共运行:800次
shutdown status:true
最后商品的库存:1

结束,共运行:800次
shutdown status:true
最后商品的库存:4

从结果中，可以看到，库存没有正确的扣减，如果对应到现实情况就是客户下单了，却没有将库现进行正确的扣减，会出现超卖的情况。

那为什么会出现这个情况呢？

再来看看商品的扣减库存的动作。

  /** 商品的库存扣减操作 */
  public void minusGoods(int num) {
    goodsNum -= num;
  }

这里采用的java的直接减法操作。减法这个动作如果在计算机上的动作指令我们可以简单的理解为3个步骤。

  1. 从主内存读取当前商品的数量至线程内。
  2. 在线程栈内进行减法运算。
  3. 将线程栈的运行的结果写回至主内存。

这时候如果多个线程同时操作这个库存数量。会出现什么情况呢？

在这里插入图片描述

由于三个线程都将本地线程中的值重新设置到主存中，这就会发生数据库存少扣的情况。具体来说就是thread1和thread2拿到了库存数量80，同时进行库存在扣减操作，thread1操作完成后，就将num的值79写回主存。这时thread2也扣减完成，结果也是79，这样就导致了一次少扣库存的情况。

4.synchronize

接下来以最常用的synchronize为例，来解决常用的并发问题。

public class Goods {

  private String name;
  private int goodsNum;

  public Goods(String name, int goodsNum) {
    this.name = name;
    this.goodsNum = goodsNum;
  }

  public synchronized void minusGoods(int num) {
    goodsNum -= num;
  }

  /**
   * 检查是否足够下单
   *
   * @return false，当前商品已经不足已下单 true 当前库存可以下单
   */
  public synchronized boolean sellOut(int nums) {
    if (goodsNum >= nums) {
      return true;
    }
    return false;
  }

  /**
   * 获取商品数量
   *
   * @return 当前商品的数量
   */
  public int getGoods() {
    return goodsNum;
  }
}

其他代码不变(包括单元测试)，这时再来运行单元测试可以发现:

结束,共运行:800次
shutdown status:true
最后商品的库存:0

库存被正确的扣减了。

这是我们最常用的保证并发的方案了。

5.lock

有了synchronized，为什么还会出现lock关键字呢？这个问题还是锁粒度的情问。synchronized关键字一般是方法锁或者对象锁，锁的粒度大，这也导致等待耗时时间也更长。而lock对象主代码块级别的锁，对于锁的粒度更小，仅在需要加锁的代码段上加锁操作。接下来将以lock方案来看看解决并发问题。

public class Goods {

  /** 商品名称 */
  private String name;

  /** 商品库存数量 */
  private int goodsNum;

  /** 锁 */
  private Lock lock = new ReentrantLock();

  public Goods(String name, int goodsNum) {
    this.name = name;
    this.goodsNum = goodsNum;
  }

  /** 商品的库存扣减操作 */
  public void minusGoods(int num) {
    lock.lock();
    try {
      // 数量检查
      if (this.sellOut(num)) {
        goodsNum = goodsNum - num;
      }
    } finally {
      lock.unlock();
    }
  }

  /**
   * 检查是否足够下单
   *
   * @return false，当前商品已经不足已下单 true 当前库存可以可以下单
   */
  public boolean sellOut(int nums) {
    if (goodsNum >= nums) {
      return true;
    }
    return false;
  }

  /**
   * 获取商品数量
   *
   * @return 当前商品的数量
   */
  public int getGoods() {
    return goodsNum;
  }
}

再看看结果:

结束,共运行:800次
shutdown status:true
最后商品的库存:0

6.volatile

volatile作为java中的关键字之一，用于声明变量的值会随时被别的线程修改，使用volatile修饰的变量会强制将修改的值立即写入主存，主存中的值设置会使缓存中的值失效（非volatile变量不具备这样的特性，非volatile变量的值会被缓存，线程A更新了这个值，线程B读取到这个变量的值可能读到的并不是线程A修改后的值）。volatile禁止指令重排。

volatile具有可见性、有序性，不具备原子性。

原子性：类比事务，通常原子性指多个操作不存在只执行一部分的情况，如果全部执行完成没有问题，如果只执行了部分，那就得摊销已经执行的部分。

可见性：当多个线程访问同一个变量A时，线程1修改了A的值，其他线程能够立即读取到A的值

有序性： 即程序按照书写的先后顺序执行。这主要是应用指令重排序的问题。在java的内存模型中，允许编译器和处理器对指令进行重新排序。但重排序的指令不会影响到单个线程的执行。却会影响并发执行的正确性。

volatile 适用场景：

适用于对变量的写入不依赖当前的值，对变量的读取不依赖volatile变量

适用于读多写入的场景。

可用作状态标识。

顺带来看下java的内存模型。

在这里插入图片描述

存放在堆上的对象可以被所有持有对这个对象引用的线程访问。当一个线程可以访问一个对象时，它也可以访问这个对象的成员变量。如果两个线程同时调用同一个对象上的同一个方法，它们将会都访问这个对象的成员变量，但是每一个线程都拥有这个成员变量的私有拷贝。因为是私有拷贝，所以在写入数据在写入时发生覆盖。

还有一个很重要的概念:happens-before

happens-before原则规则：

  1. 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；
  2. 锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作；
  3. volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；
  4. 传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；
  5. 线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；
  6. 线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；
  7. 线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；
  8. 对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；

这里就讲到了volatile变量:这是一条比较重要的规则，它标志着volatile保证了线程可见性。通俗点讲就是如果一个线程先去写一个volatile变量，然后一个线程去读这个变量，那么这个写操作一定是happens-before读操作的。

由于单独volatile不能保证原子性，所以并不能实现示例要求的功能。

7.cas

还是以下单场景为例，使用CAS机制来实现一个扣减库存的示例：

public class Goods {

  /** 商品名称 */
  private String name;

  /** 商品库存数量 添加volatile，保证内存的可见性 */
  private volatile int goodsNum;

  private static final Unsafe UNSAFE = getUnsafe();

  /** 值的偏移量 */
  private static final long valueOffset;

  /** 获取对象操作值的偏移量 */
  static {
    try {
      valueOffset = UNSAFE.objectFieldOffset(Goods.class.getDeclaredField("goodsNum"));
    } catch (Exception ex) {
      throw new Error(ex);
    }
  }

  public Goods(String name, int goodsNum) {
    this.name = name;
    this.goodsNum = goodsNum;
  }

  /**
   * 获取unsafe对象
   *
   * @return
   */
  public static Unsafe getUnsafe() {
    // 通过反射得到theUnsafe对应的Field对象
    Field field;
    try {
      field = Unsafe.class.getDeclaredField("theUnsafe");
      // 设置该Field为可访问
      field.setAccessible(true);
      // 通过Field得到该Field对应的具体对象，传入null是因为该Field为static的
      Unsafe unsafe = (Unsafe) field.get(null);
      return unsafe;
    } catch (NoSuchFieldException e) {
      e.printStackTrace();
    } catch (IllegalAccessException e) {
      e.printStackTrace();
    }
    return null;
  }

  /** 商品的库存扣减操作 */
  public void minusGoods(int num) {
    boolean updRsp;
    do {
      // 读取最新的volatile变量的值
      int goodsNumOld = UNSAFE.getIntVolatile(this, valueOffset);
      // 库存不足时，停止
      if (goodsNumOld - num < 0) {
        break;
      }
      int goodsNumNew = goodsNumOld - num;
      // 使用比较交换的原子操作执行更新
      updRsp = UNSAFE.compareAndSwapInt(this, valueOffset, goodsNumOld, goodsNumNew);
    } while (!updRsp);
  }

  /**
   * 检查是否足够下单
   *
   * @return false，当前商品已经不足已下单 true 当前库存可以可以下单
   */
  public boolean sellOut(int nums) {
    if (goodsNum >= nums) {
      return true;
    }
    return false;
  }

  /**
   * 获取商品数量
   *
   * @return 当前商品的数量
   */
  public int getGoods() {
    return goodsNum;
  }
}

运行结果:

结束,共运行:800次
shutdown status:true
最后商品的库存:0

这里使用一个Unsafe这个类，Unsafe类是在sun.misc包下，不属于Java标准。但是很多Java的基础类库，包括一些被广泛使用的高性能开发库都是基于Unsafe类开发的，比如Netty、Cassandra、Hadoop、Kafka等。Unsafe类在提升Java运行效率，增强Java语言底层操作能力方面起了很大的作用。

Unsafe类使Java拥有了像C语言的指针一样操作内存空间的能力，同时也带来了指针的问题。过度的使用Unsafe类会使得出错的几率变大，因此Java官方并不建议使用的。

此处使用两个操作getIntVolatile,从名字我们就可以看到，这是一个获取int类型的volatile修饰的变量的值。还有一个操作是compareAndSwapInt使用比较交换的原子操作，对数据进行修改操作。

如果你看过AtomicInteger的原码，你就会看到如上的代码的调用。

    /**
     * Atomically sets the value to the given updated value
     * if the current value {@code ==} the expected value.
     *
     * @param expect the expected value
     * @param update the new value
     * @return {@code true} if successful. False return indicates that
     * the actual value was not equal to the expected value.
     */
    public final boolean compareAndSet(int expect, int update) {
        return unsafe.compareAndSwapInt(this, valueOffset, expect, update);
    }

如果在平时的开发中，还是建议直接使用AtomicInteger已经封装好的类。

总结

在这章节，我总结了在java中常用的一些锁的实现方案。分别是synchronize、lock、volatile、cas这几种实现方案，并分别给出了源码。在jdk的对于锁的优化从未停止，从重量级锁到无锁，在不同的场景下，选择合适的锁。而且源码中有非常好的一些思路值得学习。

下篇文章将继续分享数据库锁

参考资料:

https://zhuanlan.zhihu.com/p/29881777

https://www.cnblogs.com/chenssy/p/6393321.html

https://baijiahao.baidu.com/s?id=1595669808533077617&wfr=spider&for=pc

https://tech.meituan.com/2018/11/15/java-lock.html

null_null_bug
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java锁详解.pdf
12-31
Java 锁是 Java 并发编程中的一种基本机制，用于确保线程安全和避免竞争条件。Java 锁可以分为两大类：synchronized 锁和 ReentrantLock 锁。 一、Synchronized 锁 1. 锁的原理：synchronized 锁是基于对象头的 ...
Java多线程中Lock锁的使用总结
08-18
Java多线程中Lock锁的使用总结 Java多线程中Lock锁的使用总结主要介绍了Java多线程中Lock锁的使用总结，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值。 知识点1: Java多线程中的...
Java中单体应用锁的局限性&分布式锁
叶为正的博客
04-22 155
补充学习资料
java 订单 锁_Java订单号生成工具（实现一）基于对象锁
weixin_39739661的博客
02-16 185
—–2017-04-17更新—–Re: claram 2017-02-04 16:15发表 [回复]回复qq_27482239：line 36： 改为 >=line 41：finOderNum 改为 finOrderNumPS：本方法可能较为笨重，应用中高并发存在重复的可能性，可参考下一篇文章《Java订单号生成工具(实现二)基于队列》—–2017-04-17更新—–Java实现的订单号生成...
分布式锁 java测试_Java锁？分布式锁？乐观锁？行锁？
weixin_32254411的博客
01-13 140
本文公众号来源：码农翻身 作者：刘欣以故事的方式来通俗易懂讲解锁的概念，建议阅读！Tomcat的锁Tomcat是这个系统的核心组成部分， 每当有用户请求过来，Tomcat就会从线程池里找个线程来处理，有的执行登录，有的查看购物车，有的下订单，看着属下们尽心尽职地工作，完成人类的请求，Tomcat就很有成就感。与此同时，它也很得意，所有的业务逻辑尽在掌握。MySQL算啥！不就是一个保存数...
java mysql订单锁释放_关于 java锁，mysql锁，以及乐观锁、悲观锁、死锁的总结
weixin_29093017的博客
01-18 209
以下都是用自己的语言的自我理解与总结，仅供参考首先，要明白为什么会有锁，简单点就是，多个进程(或者多个线程)需要同时修改同一个资源的时候，为了保证顺序修改而加的锁，如果不顺序修改，那就会错乱。1、线程和进程的区别进程：系统资源分配的最小单位，指运行中的应用程序。线程：系统分配处理器时间资源的基本单元，运行在进程中的一个单元执行流，一个进程可以有多个线程。一个进程中的多个线程之间内存数据是共享的，共...
Java互斥锁简单实例
09-03
总结来说，Java互斥锁是解决多线程环境下资源争抢和数据一致性问题的有效手段。通过`synchronized`关键字，我们可以确保在同一时间只有一个线程能够访问临界区（被同步的代码块），从而保证了线程安全。然而，过度...
Java中线程用法总结
09-03
Java中的线程是多任务处理的核心机制，它允许应用程序同时执行多个不同的操作，极大地提高了程序的并发性和效率。本文将深入探讨Java线程的常见使用技巧。 首先，线程是操作系统的基本调度单元，它们共享同一进程的...
Java中channel用法总结
09-03
在Java中，`FileChannel`提供了一个`lock()`方法用于获取文件锁。内存映射文件（memory-mapped file）可以通过`FileChannel.map()`方法实现，它将文件内容映射到内存中，可以用于线程间的同步。 5. **内存映射文件...
一分钟实现分布式锁
03-01
分布式环境下，多台机器上多个进程对一个数据进行操作，如果不做互斥，就有可能出现“余额扣成负数”，或者“商品超卖”的情况，如何实现简易分布式锁，对分布式环境下的临界资源做互斥
java分布式锁_Java分布式锁三种实现方案
weixin_39862669的博客
02-19 291
方案一：数据库乐观锁乐观锁通常实现基于数据版本(version)的记录机制实现的，比如有一张红包表(t_bonus)，有一个字段(left_count)记录礼物的剩余个数，用户每领取一个奖品，对应的left_count减1，在并发的情况下如何要保证left_count不为负数，乐观锁的实现方式为在红包表上添加一个版本号字段(version)，默认为0。异常实现流程-- 可能会发生的异常情况-- 线...
JAVA锁机制
落叶飘零z的博客
11-23 1201
乐观锁 总是认为不会产生并发问题，每次去取数据的时候总认为不会有其他线程对数据进行修改，因此不会上锁，但是在更新时会判断其他线程在这之前有没有对数据进行修改，一般会使用版本号机制或CAS操作实现。  version方式：一般是在数据表中加上一个数据版本号version字段，表示数据被修改的次数，当数据被修改时，version值会加一。当线程A要更新数据值时，在读取数据的同时也会读取versio...
Java跨进程锁定文件
weixin_33971130的博客
07-04 192
2019独角兽企业重金招聘Python工程师标准>>> ...
java 分离锁_PLock 单高效的跨进程锁，支持读写锁分离
weixin_39622150的博客
03-07 105
PLockPLock is a simple and efficient cross-process lock, also supports read-write lock. If you like this, welcome to star/fork it or follow me.PLock is an Android library, it makes Android to suppor...
掌握分布式事务锁，这个大厂实战订单锁你一定要会
weixin_33947521的博客
06-15 190
分布式趋势 目前几乎很多大型网站及应用都是分布式部署的，分布式场景中我们也都会遇到一个非常重要的问题：数据一致性。正如分布式的CAP理论说的一样：“任何一个分布式系统都无法同时满足一致性（Consistency）、可用性（Availability）和分区容错性（Partition tolerance），最多只能同时满足两项。”所以，很多系统在设计之初就要对这三者进行取舍。在互联网领域的绝大多数的...
【商品库存加锁】
qq_56921846的博客
07-07 116
在测试中调用checkStock方法，并传入productId和quantity参数，如果返回true，则说明库存充足，扣减成功；如果返回false，则说明库存不足或者其他线程正在处理。在上面的代码中，checkStock方法用于校验库存和扣减库存。先获取锁，如果获取不到锁就直接返回false，否则执行校验和扣减库存的操作。在Spring Boot中，可以使用Redis作为分布式锁来管理商品库存的加锁。
互联网大厂电商业务，扣库存操作究竟该如何加锁？
JavaEdge全是干货的技术号
11-07 2480
购物车添加商品的逻辑，随机添加三种商品，假设一个购物车中的商品是item1和item2，另一个购物车中的商品是item2和item1，一个线程先获取到了item1的锁，同时另一个线程获取到了item2的锁，然后两个线程接下来要分别获取item2和item1的锁，这个时候锁已经被对方获取了，只能相互等待一直到10s超时。虽然死锁，但因为尝试获取锁的操作并非无限阻塞，所以没有造成永久死锁，之后的改进就是避免循环等待，通过对购物车的商品进行排序来实现有顺序的加锁，避免循环等待。直接把wrong定义为静态不就行？
Java中synchronized关键字与ReentrantLock实现扣减库存
qq_37400096的博客
10-12 2296
本篇讲解单体应用中实现扣减库存，分别使用synchronized和ReentrantLock实现锁，不会出现扣除超卖的现象。
java中分段锁的理解
最新发布
07-28
Java中的分段锁（Segmented Lock）是一种并发控制机制，用于提高多线程环境下的性能。它将一个共享的数据结构划分成多个段（Segment），每个段都有自己的锁。不同的线程可以同时访问不同的段，从而减少并发访问的冲突。 分段锁的主要思想是将共享数据结构分成多个小的部分，每个部分都有自己的锁。这样，在多线程环境下，不同的线程可以同时访问不同的部分，从而提高并发性能。 具体来说，当一个线程要访问共享数据结构时，它首先需要确定要访问的段。然后，该线程只需要获取该段对应的锁，而不需要获取整个数据结构的锁。这样就可以减少锁竞争的范围，提高并发性能。 需要注意的是，分段锁适用于读多写少的场景。因为在读操作中，不同线程可以同时读取不同段的数据，不会发生冲突。而在写操作中，不同线程需要获取不同段对应的锁，只有在访问同一段时才会发生竞争。 总结来说，分段锁是一种通过将共享数据结构划分成多个段，并为每个段提供独立的锁来提高并发性能的机制。它适用于读多写少的场景，可以减小锁的粒度，降低锁竞争的概率，从而提高系统的吞吐量和响应性能。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值