【Java多线程编程实战案例】分布式系统的负载均衡模块的设计与实现

最新推荐文章于 2024-09-10 02:13:49 发布
最新推荐文章于 2024-09-10 02:13:49 发布
阅读量490 收藏 1
点赞数 1
分类专栏： # Java程序开发 文章标签： 负载均衡 volatile 原子性 可见性 加权轮询
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ARPOSPF/article/details/103949460
版权

分布式系统的负载均衡模块的设计与实现

应用场景

某分布式系统在其业务处理过程中需要通过网络连接调用下游部件提供的服务，即发送请求给下游部件。下游部件是一个集群环境（即多台主机对外提供相同的服务）。因此，该系统调用其下游部件服务的时候需要进行负载均衡控制，即保证下游部件的各台主机上接收到的请求数分布均匀（统计意义上的均匀）。

场景分析

该系统在调用其下游部件时的负载均衡模块需要在不重启应用程序、服务器的情况下满足以下几点要求：

  1. 需要支持多种负载均衡算法，例如随机轮询算法和加权随机轮询算法等
  2. 需要支持在系统运行中动态调整负载均衡算法，如从使用随机轮询算法调整为使用加权随机轮询算法。
  3. 在调用下游部件的过程中，下游部件中的非在线主机（如出现故障的主机）需要被排除在外，即发送给下游部件的请求不能派发给非在线主机（因为那样会导致请求处理失败）
  4. 下游部件的节点信息可动态调整，如处于维护的需要临时删除一个节点过后又将其重新添加回来。

设计与实现

为满足要求1，使用LoadBalancer接口对负载均衡算法进行抽象，为系统支持的每个负载均衡算法创建一个LoadBalancer实现类。

public interface LoadBalancer {
    void updateCandidate(final Candidate candidate);
    Endpoint nextEndpoint();
}

使用volatile变量修饰loadBalancer，满足当系统的启动线程或者配置管理线程更新变量loadBalancer的值之后，所有的业务线程在无须使用锁的情况下也能够读取到更新后的loadBalancer变量值。即要求2

public class ServiceInvoker {
    //保存当前类的唯一实例
    private static final ServiceInvoker INSTANCE =new ServiceInvoker();
    //负载均衡器实例，使用volatile变量保证可见性
    private volatile LoadBalancer loadBlancer;
    //私有构造器
    private ServiceInvoker(){
        //什么也不做
    }
    /*
    获取当前类的唯一实例
     */
    public static ServiceInvoker getInstance(){
        return INSTANCE;
    }

    /**
     * 根据指定的负载均衡器派发请求到特定的下游部件
     * @param request
     */
    public void dispatchRequest(Request request){
        //这里读取volatile变量loadBlancer
        Endpoint endpoint = getLoadBalancer().nextEndpoint();
        if (null==endpoint){
            // 省略其他代码

            return;
        }
        //将请求发给下游部件
        dispatchToDownstream(request,endpoint);
    }
    //真正将指定的请求派发给下游部件
    private void dispatchToDownstream(Request request, Endpoint endpoint){
        Debug.info("Dispatch request to "+endpoint+":"+request);
        //省略其他代码
    }
    public LoadBalancer getLoadBalancer(){
        //读取负载均衡器实例
        return loadBlancer;
    }
    public void setLoadBlancer(LoadBalancer loadBlancer){
        //设置或者更新负载均衡器实例
        this.loadBlancer = loadBlancer;
    }
}

维护一个心跳线程来定时检测下游部件各个节点的状态，并根据检测的结果来更新相应的节点的online实例变量，从而满足要求3.

public class Endpoint {
    public final String host;
    public final int port;
    public final int weight;
    private volatile boolean online = true;

    public Endpoint(String host, int port, int weight) {
        this.host = host;
        this.port = port;
        this.weight = weight;
    }

    public boolean isOnline() {
        return online;
    }

    public void setOnline(boolean online) {
        this.online = online;
    }

    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((host == null) ? 0 : host.hashCode());
        result = prime * result + port;
        result = prime * result + weight;
        return result;
    }

    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Endpoint other = (Endpoint) obj;
        if (host == null) {
            if (other.host != null)
                return false;
        } else if (!host.equals(other.host))
            return false;
        if (port != other.port)
            return false;
        if (weight != other.weight)
            return false;
        return true;
    }

    public String toString() {
        return "Endpoint [host=" + host + ", port=" + port + ", weight=" + weight + ", online=" + online + "]\n";
    }
}

如果要变更下游部件的节点信息，那么配置管理器只需要调整AbstractBalancer子类的updateCandidate方法即可。updateCandidate方法直接更新candidate变量的值，这里volatile保证了这个操作的原子性和可见性。即满足要求4.

public void updateCandidate(final Candidate candidate) {
    if (null == candidate || 0 == candidate.getEndpointCount()) {
        throw new IllegalArgumentException("Invalid candidate " + candidate);
    }
    //更新volatile变量candidate
    this.candidate = candidate;
}

完整代码

负载均衡接口：

public interface LoadBalancer {
    void updateCandidate(final Candidate candidate);
    Endpoint nextEndpoint();
}

负载均衡算法抽象类：

import java.util.Random;
import java.util.logging.Logger;

/**
 * 负载均衡算法抽象实现类，所有负载均衡算法实现类的父类
 */
public abstract class AbstractLoadBalancer implements LoadBalancer {
    private final static Logger LOGGER = Logger.getAnonymousLogger();
    //使用volatile变量替代锁（有条件替代）
    protected volatile Candidate candidate;
    protected final Random random;
    //心跳线程
    private Thread heartbeatThread;

    public AbstractLoadBalancer(Candidate candidate) {
        if (null == candidate || 0 == candidate.getEndpointCount()) {
            throw new IllegalArgumentException("Invalid candidate " + candidate);
        }
        this.candidate = candidate;
        random = new Random();
    }

    public synchronized void init() throws Exception {
        if (null == heartbeatThread) {
            heartbeatThread = new Thread(new HeartbeatTask(), "LB_Heartbeat");
            heartbeatThread.start();
        }
    }

    @Override
    public void updateCandidate(final Candidate candidate) {
        if (null == candidate || 0 == candidate.getEndpointCount()) {
            throw new IllegalArgumentException("Invalid candidate " + candidate);
        }
        //更新volatile变量candidate
        this.candidate = candidate;
    }

    /**
     * 留给子类实现的抽象方法
     *
     * @return
     */
    @Override
    public abstract Endpoint nextEndpoint();

    protected void monitorEndpoints() {
        //读取volatile变量
        final Candidate currCandidate = candidate;
        boolean isTheEndpointOnline;

        //检测下游部件状态是否正常
        for (Endpoint endpoint : currCandidate) {
            isTheEndpointOnline = endpoint.isOnline();
            if (doDetect(endpoint) != isTheEndpointOnline) {
                endpoint.setOnline(!isTheEndpointOnline);
                if (isTheEndpointOnline) {
                    LOGGER.log(java.util.logging.Level.SEVERE, endpoint + " offline!");
                } else {
                    LOGGER.log(java.util.logging.Level.INFO, endpoint + " is online now!");
                }
            }
        }
        //for循环结束
    }

    //检测指定的节点是否在线
    private boolean doDetect(Endpoint endpoint) {
        boolean online = true;
        // 模拟待测服务器随机故障
        int rand = random.nextInt(1000);
        if (rand <= 500) {
            online = false;
        }
        return online;
    }

    private class HeartbeatTask implements Runnable {
        @Override
        public void run() {
            try {
                while (true) {
                    //检测节点列表中的所有节点是否在线
                    monitorEndpoints();
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                //什么也不做
            }
        }
    }
    //HeartbeatTask类结束
}

加权轮询负载均衡算法：

/**
 * 加权轮询负载均衡算法实现类
 */
public class WeightedRoundRobinLoadBalancer extends AbstractLoadBalancer {
    //私有构造器
    private WeightedRoundRobinLoadBalancer(Candidate candidate) {
        super(candidate);
    }

    //通过该静态方法创建该类的实例
    public static LoadBalancer newInstance(Candidate candidate) throws Exception {
        WeightedRoundRobinLoadBalancer lb = new WeightedRoundRobinLoadBalancer(candidate);
        lb.init();
        return lb;
    }
    //在该方法中实现相应的负载均衡算法

    @Override
    public Endpoint nextEndpoint() {
        Endpoint selectedEndpoint = null;
        int subWeight = 0;
        int dynamicTotalWeight;
        final double rawRnd = super.random.nextDouble();
        int rand;

        //读取volatile变量candidate
        final Candidate candidate = super.candidate;
        dynamicTotalWeight = candidate.totalWeight;
        for (Endpoint endpoint : candidate) {
            //选取节点以及计算总权重时跳过非在线节点
            if (!endpoint.isOnline()) {
                dynamicTotalWeight -= endpoint.weight;
                continue;
            }
            rand = (int) (rawRnd * dynamicTotalWeight);
            subWeight += endpoint.weight;
            if (rand <= subWeight) {
                selectedEndpoint = endpoint;
                break;
            }
        }
        return selectedEndpoint;
    }
}

下游部件节点类：

/*
表示下游部件的节点
 */
public class Endpoint {
    public final String host;
    public final int port;
    public final int weight;
    private volatile boolean online = true;

    public Endpoint(String host, int port, int weight) {
        this.host = host;
        this.port = port;
        this.weight = weight;
    }

    public boolean isOnline() {
        return online;
    }

    public void setOnline(boolean online) {
        this.online = online;
    }

    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((host == null) ? 0 : host.hashCode());
        result = prime * result + port;
        result = prime * result + weight;
        return result;
    }

    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Endpoint other = (Endpoint) obj;
        if (host == null) {
            if (other.host != null)
                return false;
        } else if (!host.equals(other.host))
            return false;
        if (port != other.port)
            return false;
        if (weight != other.weight)
            return false;
        return true;
    }

    public String toString() {
        return "Endpoint [host=" + host + ", port=" + port + ", weight=" + weight + ", online=" + online + "]\n";
    }
}

下游部件节点列表：

import util.ReadOnlyIterator;

import java.util.Iterator;
import java.util.Set;

public final class Candidate implements Iterable<Endpoint> {
    //下游部件节点列表
    private final Set<Endpoint> endpoints;
    //下游部件节点的总权重
    public final int totalWeight;

    public Candidate(Set<Endpoint> endpoints) {
        int sum = 0;
        for (Endpoint endpoint : endpoints) {
            sum += endpoint.weight;
        }
        totalWeight = sum;
        this.endpoints = endpoints;
    }

    public int getEndpointCount() {
        return endpoints.size();
    }

    public final Iterator<Endpoint> iterator() {
        return ReadOnlyIterator.with(endpoints.iterator());
    }

    public String toString() {
        return "Candidate [endpoints=" + endpoints + ", totalWeight=" + totalWeight + "]";
    }
}

调用下游部件服务类：

import util.Debug;

public class ServiceInvoker {
    //保存当前类的唯一实例
    private static final ServiceInvoker INSTANCE =new ServiceInvoker();
    //负载均衡器实例，使用volatile变量保证可见性
    private volatile LoadBalancer loadBlancer;
    //私有构造器
    private ServiceInvoker(){
        //什么也不做
    }
    /*
    获取当前类的唯一实例
     */
    public static ServiceInvoker getInstance(){
        return INSTANCE;
    }

    /**
     * 根据指定的负载均衡器派发请求到特定的下游部件
     * @param request
     */
    public void dispatchRequest(Request request){
        //这里读取volatile变量loadBlancer
        Endpoint endpoint = getLoadBalancer().nextEndpoint();
        if (null==endpoint){
            // 省略其他代码

            return;
        }
        //将请求发给下游部件
        dispatchToDownstream(request,endpoint);
    }
    //真正将指定的请求派发给下游部件
    private void dispatchToDownstream(Request request, Endpoint endpoint){
        Debug.info("Dispatch request to "+endpoint+":"+request);
        //省略其他代码
    }
    public LoadBalancer getLoadBalancer(){
        //读取负载均衡器实例
        return loadBlancer;
    }
    public void setLoadBlancer(LoadBalancer loadBlancer){
        //设置或者更新负载均衡器实例
        this.loadBlancer = loadBlancer;
    }
}

请求派发类：

import java.io.InputStream;

public class Request {
    private final long transactionId;
    private final int transactionType;
    private InputStream in;

    public Request(long transactionId, int transactionType) {
        this.transactionId = transactionId;
        this.transactionType = transactionType;
    }

    public long getTransactionId() {
        return transactionId;
    }

    public int getTransactionType() {
        return transactionType;
    }

    public InputStream getIn() {
        return in;
    }

    public void setIn(InputStream in) {
        this.in = in;
    }

}

系统启动类：

import java.util.HashSet;
import java.util.Set;

public class SystemBooter {
    public static void main(String[] args) throws Exception {
        SystemBooter systemBooter = new SystemBooter();
        ServiceInvoker rd = ServiceInvoker.getInstance();

        LoadBalancer lb = systemBooter.createLoadBalance();

        //在main线程中设置负载均衡器实例
        rd.setLoadBlancer(lb);
    }

    //根据系统配置创建负载均衡器实例
    private LoadBalancer createLoadBalance() throws Exception {
        LoadBalancer lb;
        Candidate candidate = new Candidate(loadEndpoints());
        lb = WeightedRoundRobinLoadBalancer.newInstance(candidate);
        return lb;
    }

    private Set<Endpoint> loadEndpoints() {
        Set<Endpoint> endpoints = new HashSet<>();

        // 模拟从数据库加载以下信息
        endpoints.add(new Endpoint("192.168.101.100", 8080, 3));
        endpoints.add(new Endpoint("192.168.101.101", 8080, 2));
        endpoints.add(new Endpoint("192.168.101.102", 8080, 5));
        endpoints.add(new Endpoint("192.168.101.103", 8080, 7));
        return endpoints;
    }
}

测试函数：

import util.Tools;

public class CaseRunner {
    public static void main(String[] args) throws Exception {
        // 初始化请求派发器RequestDispatcher
        SystemBooter.main(new String[]{});

        for (int i = 0; i < Runtime.getRuntime().availableProcessors(); i++) {
            new RequestSender().start();
        }
    }

    static class RequestSender extends Thread {
        private static long id = -1;

        public RequestSender() {

        }

        static synchronized long nextId() {
            return ++id;
        }

        @Override
        public void run() {
            ServiceInvoker rd = ServiceInvoker.getInstance();
            for (int i = 0; i < 100; i++) {
                rd.dispatchRequest(new Request(nextId(), 1));
                Tools.randomPause(100);
            }
        }
    }
}

参考资料

《Java多线程编程实战指南》

镰刀韭菜
关注
专栏目录
AI系统可扩展性原理与代码实战案例讲解
程序员光剑
07-12 512
AI系统可扩展性原理与代码实战案例讲解 1. 背景介绍 1.1 问题的由来 在当今数字化时代，AI系统正以惊人的速度改变着我们的生活和工作方式。然而，随着数据量的爆炸性增长以及复杂任务的需求，AI系统面临着更高的性能要求和可扩展性挑战。可
框架设计原理与实战：理解框架的代码重用与模块化
程序员光剑
11-03 186
什么是框架？它与类库、组件、工具集之间的区别在哪里？框架最初的意义是什么？为什么现在还需要了解框架设计的原理与实践？这几个问题将作为框架的介绍。框架(Framework)是指一个或多个代码文件以及这些文件所依赖的其他资源集合，用来简化开发过程并提供特定功能的工具箱。在计算机编程领域，框架是一种设计模式，提供了一套模板或标准，用于解决常见的编程任务，比如输入/输出、网络通信等。框架有着广泛的应用，包括数据库访问、业务逻辑处理、Web应用开发、多媒体、科学计算、图形用户界面(GUI)等。
几种简单的负载均衡算法及其Java代码实现
weixin_34260991的博客
03-26 543
什么是负载均衡 负载均衡，英文名称为Load Balance，指由多台服务器以对称的方式组成一个服务器集合，每台服务器都具有等价的地位，都可以单独对外提供服务而无须其他服务器的辅助。通过某种负载分担技术，将外部发送来的请求均匀分配到对称结构中的某一台服务器上，而接收到请求的服务器独立地回应客户的请求。负载均衡能够平均分配客户请求到服务器阵列，借此提供快速获取重要数据，解决大量并发访问服务问题，这...
java中的多线程高并发与负载均衡的用途
weixin_30588729的博客
09-04 194
感觉对于这两问题的描述，大家很迷惑把 。下面我就介绍一下： 一; 什么是java的高并发，在什么情况下产生的？ 答：如果网站的访问量非常大的话，我们就应该考虑高并发的情况。 高并发的时候就是有很多用户在访问，导致系统数据不正确、糗事数据的现象。对于一些大型网站，比如门户网站，在面对大量用户访问、高并发请求方面，基本的解决方案集中在这样几个环节：使用高性能的服务器、高性能的数据库、高效率的编...
nginx负载均衡策略_nginx反向代理和负载均衡策略实战案例
weixin_39985820的博客
12-05 53
作者 | glmapper编辑 | 小胡来源 | 掘金引言先来看下nginx在web服务器排名上的趋势：存在即合理，那为什么要使用nginx呢？这得看看nginx能帮我们做些什么。首先，nginx能做反向代理【关于反向代理和正向代理此处不做说明了，感兴趣的小伙伴自行谷歌】；比方说，我想在本地使用 www.glmapper1.com 的域名去访问www.taobao.com。那么这个时候我...
负载均衡之我见
weixin_34258782的博客
02-10 72
“负载均衡”常用在处理大流量的网站，使用多台服务器，每台服务器均分担任务。 这样的好处之一就是在某一台服务器崩溃的时候，不会影响系统整体运行。好处之二就是其他服务器分担了任务，保证了性能。 Nginx和apacha都有负载均衡的相关方案。 下图是一个负载均衡的案例： 对于负载均衡而外，对外暴露的是主服务器的IP，任务的分发是由主服务器进行的，所以外界是不知道分服务器的具体IP信息的。...
java分布式系统的设计和应用_软件设计：单体应用与分布式系统
weixin_42255060的博客
02-16 791
在一个分布式系统中，一组独立的计算机展现给用户的是一个统一的整体，就好像是一个系统似的。系统拥有多种通用的物理和逻辑资源，可以动态的分配任务，分散的物理和逻辑资源通过计算机网络实现信息交换。单体应用单体应用简单讲就是把一个系统所涉及的各个组件都打包成一个一体化结构并进行部署和运行。在JavaEE领域，一体化结构很多时候体现为一个WAR包，而部署和运行的环境就是以Tomcat、weblogic为代表...
多线程与高并发实战详细内容
10-07
在IT领域，多线程和高并发是两个关键的概念，特别是在服务器端开发、分布式系统以及高性能计算中。本文将深入探讨这两个主题，并结合实战经验，为开发者提供详细的理论知识和实践指导。 一、多线程基础 1. 线程定义...
开放平台架构设计原理与实战：构建持续开放的开放平台开发流程
程序员光剑
11-05 245
近年来，互联网经济蓬勃发展，人们越来越重视对自己信息的掌控权，希望在不受限制地分享自己的知识、经验和创造力。而早已开始普及的微信、微博、知乎等社交媒体则成为人们获取信息、沟通感情、表达观点的主要渠道。如此开放的网络空间也给平台创作者提供了巨大的想象空间。然而，当平台创作者构建自己的平台时，也面临着更复杂的技术难题——如何构建可持续、可扩展、安全的开放平台？如何让平台上的用户持续地提供新的价值？更重要的是，如何将平台上生成的数据产生价值，并且持续地推动平台运营？
AI全网比价系统的实现案例
最新发布
程序员光剑
09-10 1264
自拟标题 AI全网比价系统实现案例：算法与面试题解析及代码实例 博客内容 在本博客中，我们将深入探讨AI全网比价系统的实现案例。我们将重点关注以下几个方面： AI全网比价系统的基本原理 典型面试题解析
多核多线程下，负载均衡的四种策略
weixin_46262718的博客
06-30 1336
1、单引导进程，单个备用进程 当引导进程负载过高，把任务分给备用进程处理 特点：结构简单 2、按工作内容划分工作进程 当有任务进来，按任务的工作类型指派给负责该工作类型的进程处理，例如，注册进程专门负责注册事务，查询进程专门负责查询事务 特点：分工明确，比较均衡，但是容易出现单工作类型负载过高的问题 3、随机分派工作进程 当有任务进来，随机指定工作进程 特点：更好均衡使用工作进程，但是不能控制不同事务之间的顺序，只能把要求顺序的事务封装到一个事务中， 4、轮流分派工作进程 给工作进程分配序号队列，依次分配工
多种负载均算法及其 Java 代码实现 --转
02-09 120
原文地址：https://www.oschina.net/news/81750/variety-pf-load-balancing-algorithm-and-its-java-code 首先给大家介绍下什么是负载均衡（来自百科） 负载均衡建立在现有网络结构之上，它提供了一种廉价有效透明的方法扩展网络设备和服务器的带宽、增加吞吐量、加强网络数据处理能力、提高网络的...
java平均分配算法_深度讲解微服务架构中的负载均衡算法实现
weixin_31807383的博客
12-26 582
负载均衡介绍负载均衡，英文名称为Load Balance，指由多台服务器以对称的方式组成一个服务器集合，每台服务器都具有等价的地位，都可以单独对外提供服务而无须其他服务器的辅助。通过某种负载分担技术，将外部发送来的请求均匀分配到对称结构中的某一台服务器上，而接收到请求的服务器独立地回应客户的请求。负载均衡能够平均分配客户请求到服务器阵列，借此提供快速获取重要数据，解决大量并发访问服务问题，这种集群...
多线程遇到负载均衡有问题解决方案
weixin_45268144的博客
01-28 528
@多线程遇到负载均衡有问题解决方案 多线程遇到负载均衡有问题解决方案 多线程使用 线程分配数据分发的机器节点 sentiment_host = ["192.168.50.119:33140", "192.168.50.139:33140", "192.168.50.169:33140", "192.168.50.179:33140"] factor, reminder = divmod(len(tags_cul_name), len(sentiment_host))
java 负载均衡_JAVA实现负载均衡
weixin_29589063的博客
02-12 1008
import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Random;/*** JAVA实现负载均衡**/public class TJunheng{private static char[] asciis ={'a', 'b', 'c', 'd', 'e', 'f', '...
分布式系统的负载均衡 | 架构干货
weixin_30865427的博客
07-17 537
一、 什么是负载均衡？ 什么是负载均衡？ 记得第一次接触 Nginx 是在实验室，那时候在服务器部署网站需要用 Nginx 。Nginx 是一个服务组件，用来反向代理、负载平衡和 HTTP 缓存等。那么这里的 负载均衡 是什么？ 负载均衡（LB，Load Balance），是一种技术解决方案。用来在多个资源（一般是服务器）中分配负载，达到最优化资源使用，避免过载。 资源，相当于每个服务...
聊聊多线程程序的load balance
韦编二绝
01-24 1388
文章出处：http://www.searchtb.com/2014/11/%E8%81%8A%E8%81%8A%E5%A4%9A%E7%BA%BF%E7%A8%8B%E7%A8%8B%E5%BA%8F%E7%9A%84load-balance.html 说起load balance，一般比较容易想到的是大型服务在多个replica之间的load balance、和kernel的l
高并发解决方案--负载均衡
wangchaoqi1985的博客
03-08 122
高并发解决方案--负载均衡
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

镰刀韭菜

看在我不断努力的份上，支持我吧

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值