Java面试之高并发

最新推荐文章于 2024-08-04 11:07:52 发布
最新推荐文章于 2024-08-04 11:07:52 发布
阅读量1.3k 收藏 10
点赞数
文章标签： java 多线程 并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44978620/article/details/117234966
版权

go实现12306抢票系统
秒杀系统的设计
kafka

1.sleep(0)和wait()方法

sleep()&wait()
sleep(0)详细解读，建议深度理解下
（1）从使用者角度，sleep是Thread中的方法，wait()是Object()方法；
（2）从使用地方角度，sleep可以任意使用，而wait只能在sychronized代码块中使用。
（3）从释放锁的角度来说，sleep不会释放锁，他也不需要占用锁。而wait会释放锁（但是调用它的前提是当前线程占有锁）；
（4）从唤醒角度来说，sleep在时间到了之后会自动进去可运行态。而wait()必须通过notify方法唤醒。
（5）他们都可以被interrupted（）方法打断
（6）Thread.sleep(0)

Thread.Sleep(1000) 意思是在未来的1000毫秒内本线程不参与CPU竞争，1000毫秒过去之后，这时候也许另外一个线程正在使用CPU，那么这时候操作系统是不会重新分配CPU的，直到那个线程挂起或结束，即使这个时候恰巧轮到操作系统进行CPU 分配，那么当前线程也不一定就是总优先级最高的那个，CPU还是可能被其他线程抢占去。另外值得一提的是Thread.Sleep(0)的作用，就是触发操作系统立刻重新进行一次CPU竞争，竞争的结果也许是当前线程仍然获得CPU控制权，也许会换成别的线程获得CPU控制权。

wait(1000)表示将锁释放1000毫秒，到时间后如果锁没有被其他线程占用，则再次得到锁，然后wait方法结束，执行后面的代码，如果锁被其他线程占用，则等待其他线程释放锁。注意，设置了超时时间的wait方法一旦过了超时时间，并不需要其他线程执行notify也能自动解除阻塞，但是如果没设置超时时间的wait方法必须等待其他线程执行notify。
在这里插入图片描述

2.读写锁

读写锁

一个获得了读锁的线程必须能看到前一个释放的写锁所更新的内容。读写锁比互斥锁允许对于共享数据更大程度的并发。每次只能有一个写线程，但是同时可以有多个线程并发地读数据。
在这里插入图片描述

  • 如果当前没有写锁或读锁时，第一个获取锁的线程都会成功，无论该锁是写锁还是读锁。
  • 如果当前已经有了读锁，那么这时获取写锁将失败，获取读锁有可能成功也有可能失败
  • 如果当前已经有了写锁，那么这时获取读锁或写锁，如果线程相同（可重入），那么成功；否则失败

3.多线程的实现方式？

（1）继承thread类，重写run()方法，太局限。
（2）实现runable()接口
（3）实现Callnable接口，重写call方法，带有返回值
（4）线程池的方式

4.java锁的种类？公平锁/非公平锁；可重入锁；互斥锁/读写锁；乐观锁/悲观锁；

读写锁

5.线程的同步方式？

6.volatile和synchronized关键字的原理

为什么synchronized安全？
使用 javap -v 查看字节码文件发现，monitorenter 和 monitorexit 两个独有的指令。执行同步代码后首先要先执行 monitorenter 指令，退出的时候monitorexit 指令。使用Synchronized 进行同步，其关键就是必须要对对象的监视器 monitor 进行获取，当线程获取 monitor 后才能继续往下执行，否则就只能等待。而这个获取的过程是互斥的，即同一时刻只有一个线程能够获取到monitor。
在这里插入图片描述

volatile禁止指令重排：

  • 在jvm层级，被volatile关键字修饰的变量，对其读写需要添加内存屏障，内存屏障的意思就是在本条指令前后添加内存屏障，不让其和前面和后面的指令重排序。那么是怎么实现的呢？通过查看源码，可以发现其底层采用 lock 这条指令实现。 lock指令的意思就是强制刷新cpu的缓存。确保获取的是最新数据。就是将我们之前指令修改的数据都刷新到缓存中，确保其立即生效。而lock之后，也就是我们volatile修饰的变量就不会参与指令的重排序。

“观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令”
lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：
1）它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面；即在执行到内存屏障这句指令时，在它前面的操作已经全部完成；
2）它会强制将对缓存的修改操作立即写入主存；
3）如果是写操作，它会导致其他CPU中对应的缓存行无效。

7.ConcourrentHashMap怎么保证线程安全

8.怎么保证线程安全？

  • 首先应该避免全局变量，采用局部变量。如果非要使用的话，可以采用final类型，或者使用ThreadLocal;
  • 对于单个变量共享的话，可以采用volatile关键字来确保线程安全；
  • 委托线程安全的类去保证线程安全(并发容器(vector)、同步容器concurrentHashMap)
  • 如果代码块需要同步的话，可以采用lock和synchronized。

9.Java结束线程的三种的方式？

参考

  • 线程run()方法执行结束，正常退出；
  • 使用interrupt()方法中断线程。当线程调用sleep()方法之后，通过try-catch来捕获异常，然后结束线程。假如线程run()方法是个while循环。
  • 使用stop()方法，不建议，立即释放锁，停止线程，使得某些操作可能得不到执行，引发数据不安全问题。
  • 设置一个标志，用来退出，一般是volatile修饰的。

10.CAS原理

CAS并发原语提现在Java语言中就是sun.miscUnSafe类中的各个方法。调用UnSafe类中的CAS方法,JVM会帮我实现CAS汇编指令.这是一种完全依赖于硬件 功能,通过它实现了原子操作。再次强调,由于CAS是一种系统原语,原语属于操作系统用于范畴,是由若干条指令组成,用于完成某个功能的一个过程,并且原语的执行必须是连续的,在执行过程中不允许中断,也即是说CAS是一条原子指令,不会造成所谓的数据不一致的问题。

11.原子类Atomiclnteger的ABA问题谈谈?原子更新引用知道吗？

12.CountDownLatch/CyclicBarrier/Semaphore使用过吗？

13.阻塞队列知道吗？

阻塞队列

14.线程池用过吗？ThreadPoolExecutor谈谈你的理解？

线程池
AbortPolicy：直接抛出异常，阻止系统正常运行。
CallerRunsPolicy ：只要线程池未关闭，该策略直接在调用者线程中，运行当
前被丢弃的任务。显然这样做不会真的丢弃任务，但是，任务提交线程的性能极
有可能会急剧下降。
DiscardOldestPolicy ：丢弃最老的一个请求，也就是即将被执行的任务，并
尝试再次提交当前任务。
DiscardPolicy ：该策略默默地丢弃无法处理的任务，不予任何处理。如果允
许任务丢失，这是最好的一种方案。

常用线程池：

  1. Executors.newSingleThreadExecutor()：只有一个线程的线程池，因此所有提交的任务是顺序执行，适用于一个一个任务执行的场景
  2. Executors.newCachedThreadPool()：线程池里有很多线程需要同时执行，老的可用线程将被新的任务触发重新执行，如果线程超过 60 秒内没执行，那么将被终止并从池中删除，适用执行很多短期异步的小程序或者负载较轻的服务
  3. Executors.newFixedThreadPool()：拥有固定线程数的线程池，如果没有任务执行，那么线程会一直等待，适用执行长期的任务，性能好很多。
  4. Executors.newScheduledThreadPool()：用来调度即将执行的任务的线程池
  5. newWorkStealingPool(int parallelism)，这是一个经常被人忽略的线程池，Java 8 才加入这个创建方法，其内部会构建 ForkJoinPool，利用Work-Stealing 算法，并行地处理任务，不保证处理顺序。

FixedThreadPool 和 SingleThreadExecutor ： 允许请求的队列⻓度为
Integer.MAX_VALUE，可能堆积⼤量的请求，从⽽导致 OOM。
CachedThreadPool 和 ScheduledThreadPool ： 允许创建的线程数量为
Integer.MAX_VALUE，可能会创建⼤量线程，从⽽导致 OOM。

线程池大小的设定：

  1. CPU密集型（该任务需要大量的运算，而没有阻塞，cpu一直全速运行）（CPU核数+1）
  2. IO密集型（CPU*2）(cpu核数/（1-阻塞系数）系数在0.8-0.9之间)

15.lock中独占锁和共享锁的实现：

16.谈谈LockSupport

17.线程的状态

  1. new （new出了线程对象，但还没有调用start()方法）
  2. running（就绪和运行）
  3. blocked（阻塞状态，其中有一个 monitor lock 字眼，了解sychronized关键字的应该比较熟悉。不就是对象监视器吗。重量级锁实现的依赖。那么回到这里，说明这个状态是在等待其他线程释放锁。）
  4. waitting（需要其他线程唤醒）
  5. time_waitting（有时间参数，到了时间自动唤醒）
  6. TERMINATED（这个状态比较好理解，其实就是我们的线程执行结束了。也就是run()方法中的代码执行完成）

线程状态之间的转换
在这里插入图片描述

18.sleep（） 、wait()、yield()、join() 、park()的区别

  1. sleep方法在Thread中的方法，调用的过程中不会释放锁，进行阻塞，睡眠时间到后自动释放执行。
  2. wait()方法，Object中的方法，调用的时候会阻塞当前线程，并且会释放锁。自己不能从等待状态中出来，需要其他线程调用notify()方法。并且只能在同步代码块中使用，因为是需要释放锁的。
  3. yield方法，也是Thread中的方法，同样不会释放锁，会让出当前cpu的执行权，和sleep方法不同的是，他不会进行阻塞，只是将当前线程调整为可运行态，那么就可能存在刚调用这个方法后，该线程又立马执行。
  4. join（）方法，用来确保线程的执行顺序，调用join方法会优先执行，是Thread中的一个实例方法，但底层采用wait方法实现，所以会释放锁。thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。
  5. park（）方法是unsafe类中的方法，用来使用在并发包中，比wait更灵活，可以通过unpark方法唤醒指定线程。感觉sleep()方法更强调的是放弃cpu竞争权力多少秒。而wait()方法强调的是线程间的通信。

19.Stop 和 suspend方法

stop以及suspend

20. 锁和同步的区别：用法、实现、性能

添加链接描述

21.JMM: 讨论的是并发的问题，主内存、工作内存。从原子性、有序性、可见性分析。

22.java中用到的定时任务：

（1）Timer类，缺点，单个线程执行任务，当前一个任务出现问题时，会影响后续的任务 . （2）SpringBoot定时器：

23. NIO中三种reactor模式：

（1）单线程，处理单个事件如果过慢，就会造成其他事件拥堵情况。
（2）线程池，单个线程只处理分发任务，具体执行流程交给线程池执行。这时候单个线程的分发可能会成为瓶颈，比如说我们有一万个连接，同时还有一万个正在写的事件。那么单线程的分发负载就会过大。
（3）主从模式，主select()负责处理连接，而从select()负责读写事件。支持高程度的并发。

24.锁消除和锁粗化

锁消除和锁粗话

25.公平锁和非公平锁区别？为什么公平锁效率低？

公平锁：
公平锁自然是遵循 FIFO（先进先出）原则的，先到的线程会优先获取资源，后
到的会进行排队等待
优点：所有的线程都能得到资源，不会饿死在队列中。
缺点：吞吐量会下降，队列里面除了第一个线程，其他的线程都会阻塞，cpu
唤醒阻塞线程的开销大
非公平锁：
多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，
如果能获取到，就直接获取到锁。
优点：可以减少 CPU 唤醒线程的开销，整体的吞吐效率会高点，CPU 也不必取
唤醒所有线程，会减少唤起线程的数量。
缺点：你们可能也发现了，这样可能导致队列中间的线程一直获取不到锁或者
长时间获取不到锁
公平锁效率低原因：
公平锁要维护一个队列，后来的线程要加锁，即使锁空闲，也要先检查有没有
其他线程在 wait，如果有自己要挂起，加到队列后面，然后唤醒队列最前面线
程。这种情况下相比较非公平锁多了一次挂起和唤醒。
线程切换的开销，其实就是非公平锁效率高于公平锁的原因，因为非公平锁减
少了线程挂起的几率，后来的线程有一定几率逃离被挂起的开销。

26.JMM

Java 内存模型（Java Memory Model，JMM）就是一种符合内存模型规范的，屏蔽了各种硬件和操作系统的访问差异的，保证了 Java 程序在各种平台下对内存的访问都能保证效果一致的机制及规范。

JMM 是一种规范，是解决由于多线程通过共享内存进行通信时，存在的本地内
存数据不一致、编译器会对代码指令重排序、处理器会对代码乱序执行等带来的
问题。目的是保证并发编程场景中的原子性、可见性和有序性。

所以，Java 内存模型，除了定义了一套规范，还提供了一系列原语，封装了底
层实现后，供开发者直接使用。我们前面提到，并发编程要解决原子性、有序性
和一致性的问题。

27.手写简单的线程池，提现线程的复用

手写线程池

28.手写生产者 消费者

package pro_cum;

public class sync {
    public static void main(String[] args) {
        Data data=new Data();
        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.increase();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"A").start();

        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.decrease();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"B").start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.increase();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"C").start();

        new Thread(()->{
            for(int i=0;i<10;i++){
                try {
                    data.decrease();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },"D").start();


    }
}
class Data{
    private int num=0;
    public synchronized void increase() throws InterruptedException {
        while(num!=0){
            this.wait();
        }
        num++;
        System.out.println(Thread.currentThread().getName() + "值为:" + num);
        this.notifyAll();
    }
    public synchronized void decrease() throws InterruptedException {
        while(num==0){
            this.wait();
        }
        num--;
        System.out.println(Thread.currentThread().getName() + "值为:" + num);
        this.notifyAll();
    }
}

29.手写阻塞队列

手写阻塞队列

30.手写多线程循环打印ABC

package leetcode;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ABC {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        Runnable runa=new Runnable() {
            @Override
            public void run() {
                System.out.println("A");
                //executorService.execute(this::run);
            }
        };
        Runnable runb=new Runnable() {
            @Override
            public void run() {
                System.out.println("B");
                //executorService.execute(this::run);
            }
        };
        Runnable runc=new Runnable() {
            @Override
            public void run() {
                System.out.println("C");
                //executorService.execute(this::run);
            }
        };
        for(int i=0;i<10;i++){
        executorService.execute(runa);
        executorService.execute(runb);
        executorService.execute(runc);}
    }
}


package pro_cum;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LOCK {
    public static void main(String[] args) {
        Data1 data=new Data1();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.printA();
            }
        }).start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.printB();
            }
        }).start();
        new Thread(()->{
            for(int i=0;i<10;i++){
                data.printC();
            }
        }).start();
    }
}
class Data1{
    private Lock lock = new ReentrantLock();
    private Condition condition1 = lock.newCondition();
    private Condition condition2 = lock.newCondition();
    private Condition condition3 = lock.newCondition();
    private int num=1;

    public void printA(){
        lock.lock();
        try{
            while(num!=1){
                condition1.await();
            }
            num++;
            System.out.println("A");
            condition2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printB(){
        lock.lock();
        try{
            while(num!=2){
                condition2.await();
            }
            num++;
            System.out.println("B");
            condition3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
    public void printC(){
        lock.lock();
        try{
            while(num!=3){
                condition3.await();
            }
            num=1;
            System.out.println("C");
            condition1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
        }
    }
}

31.死锁代码

在这里插入图片描述

早起的虫子jj
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java面试处理高并发
如此思恋的博客
12-28 2325
1 从最基础的地方做起，优化我们写的代码，减少必要的资源浪费。         a、避免频繁的使用new对象，对于整个应用只需要存在一个实例的类，我们可以使用单例模式。对于String连接操作，使用      StringBuffer或StringBuilder，对于工具类可以通过静态方法来访问。         b、避免使用错误的方式，尽量不用instanceof做条件判断。使用java中效...
java高并发面试题目_列举Java高并发面试题附答案解析
weixin_34532234的博客
03-02 3807
Java高并发面试题是程序员面试过程中的必修课，只有熟练掌握这些技术要点，在我们的学习中才会脱颖而出，在这里，达内石家庄Java培训老师作深入解答。Java并发面试题附答案1. 什么是原子操作?在Java Concurrency API中有哪些原子类(atomic classes)?原子操作是指一个不受其他操作影响的操作任务单元。原子操作是在多线程环境下避免数据不一致必须的手段。int++并不是一...
java面试题（并发）
Java小菜鸟
03-19 1724
java多线程、java spring 、spring mvc、 spring boot面试题
java项目中的高并发处理
lw_jack的博客
06-17 906
简要介绍项目的业务场景和功能，以及为什么需要高并发处理。
Java面试题整理-高并发篇
weixin_44399827的博客
12-20 2540
1. synchronized的实现原理以及锁优化？ synchronized原理分析_遇见更好的自己、的博客-CSDN博客Java 高并发专题之synchronized关键字1、synchronized作为jvm关键字有三个作用域synchronized作用于实例方法锁住的当前对象。只有当前对象被锁住。新new出来的对象不会被锁住。synchronized作用于静态方法锁住的是当前的是类对象：只要是new出来的对象都会被锁住。synchronized同步代码块锁住代码块所对应的对象方法、2、Java对象
java面试八股文
weixin_45927841的博客
03-21 5万+
目录一、java（1）集合1.list：LinkedList、ArrayList和Vector2.set：HashSet和TreeSet3.map：HashMap、TreeMap和HashTable4.list和set的区别（2）其他1.面向对象三大特性2.Object类的常用方法3.Java中线程安全的基本数据结构4.string、stringBuffer和stringBuilder5.抽象类与接口的区别6.java的基本数据类型7.java代码块执行顺序8.static关键字9.覆盖（重写）和重载的区别
java高分面试指南：java高并发秒杀面试题
m0_57064331的博客
07-20 1318
一，session共享 首先第一个要解决的就是sesison共享的问题，如下图。 通常有两种解决方案，第1种是配置nginx的负载集群策略为ip_hash，第2种是将session存储到其它地方，一般推荐放到redis中。 第1种方案适合于临时解决或者是为了兼容历史项目，但是从应用服务器无状态的角度考虑，推荐把用户会话session放到redis，如下图。 二，本地缓存 如果使用本地缓存，当从单体迁移到集群后，就会面临缓存同步的问题，如下图。 最佳实践是上分布式缓存，既解决了缓存同步的问题，也释放了应
Java并发编程面试题（2022最新版）
weixin_45985053的博客
07-25 1412
多线程多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务。多线程编程中一般线程的个数都大于CPU核心的个数，而一个CPU核心在任意时刻只能被一个线程使用，为了让这些线程都能得到有效执行，CPU采取的策略是为每个线程分配时间片并轮转的形式。当一个线程的时间片用完的时候就会重新处于就绪状态让给其他线程使用，这个过程就属于一次上下文切换。概括来说就是任务从保存到再加载的过程就是一次上下文切换。上下文切换通常是计算密集型的。互斥条件AtomicLong。......
Java面试中常见的高并发解决方案
m0_55613022的博客
06-24 1330
一般来讲，提高系统应对高并发能力的解决方案可以从以下几个方面入手： （1）高性能服务器 （2）高性能数据库 （3）高效编程语言 （4）高性能web容器提高数据库性能，解决高并发问题提高项目语言效率，解决高并发问题...
Java后端真实面试题大全(有详细答案)--高频/真题
热门推荐
IT利刃出鞘的博客
11-24 13万+
本文分享Java后端真实高频面试题，有详细答案，保你稳过面试。题目包括：Java基础、多线程、JVM、数据库、Redis、Shiro、Spring、SpringBoot、MyBatis、MQ、ELK、SpringCloud、设计模式等。 本博客包含从简单到困难、从高频到低频的题目，适合所有Java求职者，包括：刚入门的、三年以内经验、三到五年经验、五到十年经验等。
2023 java面试 高并发手册
02-21
2023 java面试 高并发手册
java面试题高级, 对底层高并发深入理解
03-13
在Java面试中，对于高级职位，面试官通常会考察应聘者对Java语言的深入理解和在高并发环境下的处理能力。以下是一些相关的知识点： 1. **JVM内存模型**：了解Java虚拟机（JVM）的工作原理至关重要。JVM内存分为堆...
2023年最新Java高并发多线程面试题
01-23
以下是一些关于Java高并发多线程的面试知识点，包括相关概念、使用技巧和解决策略。 1. **线程死锁**：线程死锁是多线程环境下的一种状态，其中两个或更多线程相互等待对方释放资源，导致它们都无法继续执行。避免...
Java高并发面试题汇总
06-15
Java高并发面试题 Java高并发面试题 Java高并发面试题 Java高并发面试题 Java高并发面试题 Java高并发面试题 Java高并发面试题
Java高并发编程，构建并发编程知识体系，提升面试成功率
09-23
Java高并发编程，构建并发编程知识体系，提升面试成功率，完整版17章视频教程下载。 本课程将结合大量图示及代码演示，带你掌握多线程并发编程（线程安全，线程调度，线程封闭，同步容器等）与高并发处理思路与手段...
枚举工具类
qq_43049583的博客
08-04 195
java枚举工具类
等待唤醒机制两种实现方法-阻塞队列
最新发布
泰勒今天想展开的博客
08-04 197
桌子上有面条-》吃货执行桌子上没面条-》生产者制造执行。
社区养老服务小程序的设计
Karen198的博客
07-31 593
管理员账户功能包括：系统首页，个人中心，用户管理，服务人员管理，服务产品管理，服务预约管理，服务状态管理，服务退订管理，活动管理，视频管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。服务器：SpringBoot自带 apache tomcat。微信端账号功能包括：系统首页，服务产品，活动，视频，我的。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。
2023 Java面试精华：高并发与数据结构详解
在2023年的Java面试中，高并发和数据结构相关的知识点是重点考察内容。以下是一些关键的面试题目及概念解析： 1. **集合类概览**： - **Set** 类型包括 `TreeSet` 和 `HashSet`。`TreeSet` 是基于红黑树实现的，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值