多线程设计模式-主动对象模式

最新推荐文章于 2023-09-24 15:01:19 发布
最新推荐文章于 2023-09-24 15:01:19 发布
阅读量278 收藏 1
点赞数
分类专栏： 多线程设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010145219/article/details/91348816
版权

定义： 一种异步编程模式，允许任务的提交（对异步方法的调用）和任务的执行（异步方法的真正执行）分离

主动对象模式UML图

Proxy: 负责对外暴露异步方法接口
    asyncService: 该异步方法负责创建与该方法相应的MethodRequest参与者实例，并将其提交给Scheduler参与者实例。该方法的返回值是一个Future参与者实例，客户端代码可以通过它获取异步方法对应的任务的执行结果
MethodRequest: 负责将客户端代码对Proxy实例的异步方法的调用封装成一个对象，该对象保留异步方法的名称及客户端代码传递的参数等上下文参数。它使Proxy的异步方法的调用和执行分离成为可能
    call: 根据其所属MethodRequest实例所包含的上下文信息调用Servant实例的相应方法
ActivationQueue: 缓冲区，用于临时存储由Proxy的异步方法被调用时所创建的MethodRequest实例
    enqueue: 将MethodRequest实例放入缓冲区
    dequeue: 从缓冲区中取出一个MethodRequest实例
Scheduler: 负责将Proxy的异步方法所创建的MethodRequest实例存入其维护的缓冲区中，并根据一定的调度策略，对其维护的缓冲区中的MethodRequest实例进行执行。其调度策略可以根据实际需要来定，如FIFO，LIFO和根据MethodRequest中包含的信息所定的优先级等
    enqueue: 接受一个MethodRequest实例，并将其存入缓冲区
    dispatch: 反复地从缓冲区中取出MethodRequest实例进行执行
Servant: 负责Proxy所暴露的异步方法的具体实现
    doSomething: 执行Proxy所暴露的异步方法对应的任务
Future: 负责存储和获取主动对象模式异步方法的执行结果
    get: 获取异步方法对应的任务的执行结果
    set: 设置异步方法对应的任务的执行结果

有时候请求发送过来会因为网络问题或者数据库问题等问题出现失败的情况，为了避免错失重要的请求，这时候可以将请求做持久化处理，缓存到磁盘，等问题解决后再继续处理。由于缓存到磁盘涉及到文件IO，操作缓慢，不希望因此导致延时的增加，此时可以使用异步处理的方式。下列代码MMSDeliveryServlet#doPost()方法检测到有数据库发送异常，调用store()方法将请求缓存起来。

package com.bruce.activeObject;

import java.io.Serializable;
import java.util.Arrays;

/**
* @Author: Bruce
* @Date: 2019/6/4 21:33
* @Version 1.0
*/
public class Attachment implements Serializable {

    private static final long serialVersionUID = -3242951327009946609L;
    private String contentType;
    private byte[] content = new byte[0];

    public String getContentType() {
        return contentType;
    }

    public void setContentType(String contentType) {
        this.contentType = contentType;
    }

    public byte[] getContent() {
        return content;
    }

    public void setContent(byte[] content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "Attachment {" +
                "contentType='" + contentType + '\'' +
                ", content=" + Arrays.toString(content) +
                '}';
    }
}
package com.bruce.activeObject;

import java.io.Serializable;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;

/**
* @Author: Bruce
* @Date: 2019/6/4 21:31
* @Version 1.0
*/
public class Recipient implements Serializable {

    private static final long serialVersionUID = 2208629750371068868L;
    private Set<String> to = new HashSet<String>();

    public void addTo(String msisdn) {
        to.add(msisdn);
    }

    public Set<String> getToList() {
        return (Set<String>) Collections.unmodifiableCollection(to);
    }
}
package com.bruce.activeObject;

import java.io.Closeable;

/**
* @Author: Bruce
* @Date: 2019/6/4 21:44
* @Version 1.0
*/
public interface RequestPersistence extends Closeable {
    void store(MMSDeliverRequest request);
}
package com.bruce.activeObject;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicLong;

/**
* @Author: Bruce
* @Date: 2019/6/4 21:43
* @Version 1.0
*/
public class AsyncRequestPersistence implements RequestPersistence {

    private static final long ONE_MINUTE_IN_SECONDS = 60;
    final static Logger logger = LoggerFactory.getLogger(AsyncRequestPersistence.class);
    final AtomicLong taskTimeConsumedPerInterval = new AtomicLong(0);
    final AtomicLong requestSubmittedPerInterval = new AtomicLong(0);

    private final DiskbasedRequestPersistence delegate =
            new DiskbasedRequestPersistence();

    private final ThreadPoolExecutor scheduler;

    private static class InstanceHolder {
        final static RequestPersistence INSTANCE = new AsyncRequestPersistence();
    }

    private AsyncRequestPersistence() {
        scheduler = new ThreadPoolExecutor(1, 3, 60 * ONE_MINUTE_IN_SECONDS, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(200), new ThreadFactory() {
            @Override
            public Thread newThread(Runnable r) {
                Thread t;
                t = new Thread(r, "AsyncRequestPersistence");
                return t;
            }
        });

        scheduler.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(6);

        TimerTask task = new TimerTask() {
            @Override
            public void run() {
                if (logger.isInfoEnabled()) {
                    logger.info("task count: " + requestSubmittedPerInterval
                            + ", Queue size: " + scheduler.getQueue().size()
                            + ", taskTimeConsumedPerInterval: "
                            + taskTimeConsumedPerInterval.get() + " ms");
                }
                taskTimeConsumedPerInterval.set(0);
                requestSubmittedPerInterval.set(0);
            }
        };

        scheduledExecutorService.scheduleAtFixedRate(task, 0,ONE_MINUTE_IN_SECONDS * 1000, TimeUnit.SECONDS);
    }

    public static RequestPersistence getInstance() {
        return InstanceHolder.INSTANCE;
    }

    @Override
    public void store(final MMSDeliverRequest request) {
        Callable<Boolean> methodRequest = new Callable<Boolean>() {
            @Override
            public Boolean call() throws Exception {
                long start = System.currentTimeMillis();
                try {
                    delegate.store(request);
                } finally {
                    taskTimeConsumedPerInterval.addAndGet(System.currentTimeMillis() - start);
                }
                return Boolean.TRUE;
            }
        };
        scheduler.submit(methodRequest);

        requestSubmittedPerInterval.incrementAndGet();
    }

    @Override
    public void close() throws IOException {
        scheduler.shutdown();
    }
}
package com.bruce.activeObject;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sun.rmi.runtime.Log;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;

/**
* @Author: Bruce
* @Date: 2019/6/4 21:47
* @Version 1.0
*/
public class DiskbasedRequestPersistence implements RequestPersistence{

    final SectionBasedDiskStorage storage = new SectionBasedDiskStorage();

    private Logger LOG = LoggerFactory.getLogger(DiskbasedRequestPersistence.class);

    @Override
    public void store(MMSDeliverRequest request) {
        String[] fileNameParts = storage.apply4Filename(request);
        File file = new File(fileNameParts[0]);
        try (ObjectOutputStream objOutput = new ObjectOutputStream(new FileOutputStream(file));) {
            objOutput.writeObject(request);
        } catch (IOException e) {
            storage.decrementSectionFileCount(fileNameParts[1]);
            LOG.error("Failed to store request");
        }
    }

    @Override
    public void close() throws IOException {

    }

    class SectionBasedDiskStorage {

        private Deque<String> sectionNames = new LinkedList<String>();
        private Map<String/*Storage Directory*/, AtomicInteger/*Counter*/> sectionFileCountMap =
                new HashMap<>();
        private int maxFilesPerSection = 2000;
        private int maxSectionCount = 100;
        private String storageBaseDir = "C:\\Users";
        private final Object sectionLock = new Object();


        public SectionBasedDiskStorage() {
            File dir = new File(storageBaseDir);
            if (!dir.exists()) {
                dir.mkdirs();
            }
        }

        public String[] apply4Filename(MMSDeliverRequest request) {
            String sectionName;
            int iFileCount;
            String oldestSectionName = null;
            String[] fileName = new String[2];
            synchronized (sectionLock) {
                sectionName = getSectionName();
                AtomicInteger fileCount;
                fileCount = sectionFileCountMap.get(sectionName);
                iFileCount = fileCount.get();
                if (iFileCount >= maxFilesPerSection) {
                    if (sectionNames.size() >= maxSectionCount) {
                        oldestSectionName = sectionNames.removeFirst();
                    }
                    sectionName = makeNewSectionDir();
                    fileCount = sectionFileCountMap.get(sectionName);
                }
                iFileCount = fileCount.addAndGet(1);
            }

            fileName[0] = storageBaseDir + "/" + sectionName + "/"
                    + new DecimalFormat("0000").format(iFileCount) + "-"
                    + request.getTimeStamp().getTime() / 1000 + "-"
                    + request.getExpiry() + ".rq";
            fileName[1] = sectionName;


            if (null != oldestSectionName) {
                this.removeSection(oldestSectionName);
            }
            return fileName;
        }

        public void decrementSectionFileCount(String sectionName) {
            AtomicInteger fileCount = sectionFileCountMap.get(sectionName);
            if (null != fileCount) {
                fileCount.decrementAndGet();
            }
        }

        private boolean removeSection(String sectionName) {
            boolean result = true;
            File dir = new File(storageBaseDir + "/" + sectionName);
            for (File file : dir.listFiles()) {
                result = result && file.delete();
            }
            result = result && dir.delete();
            return result;
        }

        private String getSectionName() {
            String sectionName;
            if (sectionNames.isEmpty()) {
                sectionName = this.makeNewSectionDir();
            } else {
                sectionName = sectionNames.getLast();
            }
            return sectionName;
        }

        private String makeNewSectionDir() {
            String sectionName;
            SimpleDateFormat sdf = new SimpleDateFormat("MMddMM HHmmss");
            sectionName = sdf.format(new Date());
            File dir = new File(storageBaseDir + "/" + sectionName);
            if (dir.mkdir()) {
                sectionNames.addLast(sectionName);
                sectionFileCountMap.put(sectionName, new AtomicInteger(0));
            } else {
                throw new RuntimeException("Cannot create section dir " + sectionName);
            }
            return sectionName;
        }
    }
}
package com.bruce.activeObject;

import java.io.Serializable;
import java.util.Date;

/**
* @Author: Bruce
* @Date: 2019/6/4 21:29
* @Version 1.0
*/
public class MMSDeliverRequest implements Serializable {

    private String transactionID;
    private String messageType = "Delivery.req";
    private String senderAddress;

    private Recipient recipient = new Recipient();
    private String subject;
    private Attachment attachment = new Attachment();

    private long expiry;
    private Date timeStamp;

    public MMSDeliverRequest() {
    }

    public String getTransactionID() {
        return transactionID;
    }

    public void setTransactionID(String transactionID) {
        this.transactionID = transactionID;
    }

    public String getMessageType() {
        return messageType;
    }

    public void setMessageType(String messageType) {
        this.messageType = messageType;
    }

    public String getSenderAddress() {
        return senderAddress;
    }

    public void setSenderAddress(String senderAddress) {
        this.senderAddress = senderAddress;
    }

    public Recipient getRecipient() {
        return recipient;
    }

    public void setRecipient(Recipient recipient) {
        this.recipient = recipient;
    }

    public String getSubject() {
        return subject;
    }


    public void setSubject(String subject) {
        this.subject = subject;
    }


    public Attachment getAttachment() {
        return attachment;
    }

    public void setAttachment(Attachment attachment) {
        this.attachment = attachment;
    }

    public long getExpiry() {
        return expiry;
    }

    public void setExpiry(long expiry) {
        this.expiry = expiry;
    }

    public Date getTimeStamp() {
        return timeStamp;
    }

    public void setTimeStamp(Date timeStamp) {
        this.timeStamp = timeStamp;
    }

    @Override
    public String toString() {
        return "MMSDeliverRequest {" +
                "transactionID='" + transactionID + '\'' +
                ", messageType='" + messageType + '\'' +
                ", senderAddress='" + senderAddress + '\'' +
                ", recipient=" + recipient +
                ", subject='" + subject + '\'' +
                ", attachment=" + attachment +
                ", timeStamp=" + timeStamp +
                '}';
    }
}
package com.bruce.activeObject;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;

/**
* @Author: Bruce
* @Date: 2019/6/4 21:22
* @Version 1.0
*/
public class MMSDeliveryServlet extends HttpServlet {

    private Logger LOG = LoggerFactory.getLogger(MMSDeliverRequest.class);

    private static final long serialVersionUID = -5177695993579658630L;

    @Override
    public void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        MMSDeliverRequest mmsDeliveryRequest = this.parseRequest(req.getInputStream());
        Recipient shortNumberRecipient = mmsDeliveryRequest.getRecipient();
        Recipient originalNumberRecipient = null;

        try {
            originalNumberRecipient = convertShortNumber(shortNumberRecipient);
        } catch (SQLException e) {

            AsyncRequestPersistence.getInstance().store(mmsDeliveryRequest);

            resp.setStatus(202);

        }

        LOG.info(String.valueOf(originalNumberRecipient));
    }

    private MMSDeliverRequest parseRequest(InputStream reqInputStream) {

        MMSDeliverRequest mmsDeliverRequest = new MMSDeliverRequest();
        return mmsDeliverRequest;

    }

    private Recipient convertShortNumber(Recipient shortNumberRecipient) throws SQLException {
        Recipient recipient = null;


        return recipient;
    }
}
package com.bruce.activeObject;

import java.io.IOException;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Date;
import java.util.concurrent.atomic.AtomicInteger;

/**
* @Author: Bruce
* @Date: 2019/6/5 2:12
* @Version 1.0
*/
public class CaseRunner {

    public static void main(String[] args) {

        int numRequestThreads = Runtime.getRuntime().availableProcessors();
        int targetTPS = 50;
        float duration = 12;

        final RequestSender reqSender = new RequestSender(
                (int) duration * targetTPS
        );
    }

    static class RequestSender implements Runnable {

        final AtomicInteger totalCount = new AtomicInteger();
        private final RequestPersistence persistence;
        private final Attachment attachment;

        public RequestSender(int n) {
            totalCount.set(n);
            persistence = AsyncRequestPersistence.getInstance();
            attachment = new Attachment();
            try {
                URL url = CaseRunner.class.getClassLoader().getResource("C:\\Users\\Bruce\\Pictures\\Camera Roll\\0.jpg");
                attachment.setContentType("image/jpeg");
                attachment.setContent(Files.readAllBytes(Paths.get(url.toURI())));
            } catch (URISyntaxException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        @Override
        public void run() {
            int remainingCount;
            while ((remainingCount = totalCount.getAndDecrement()) > 0) {
                MMSDeliverRequest request = new MMSDeliverRequest();
                request.setTransactionID(String.valueOf(remainingCount));
                request.setSenderAddress("1234566987");
                request.setTimeStamp(new Date());
                request.setExpiry((System.currentTimeMillis() + 3600000) / 1000);

                request.setSubject("Hi");
                request.getRecipient().addTo("776");
                request.setAttachment(attachment);
                persistence.store(request);
            }
        }

        public void shutdown() {
            try {
                persistence.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}


主动对象模式的好处是将方法的调用和执行分离，实现了异步编程，有利于提高并发性，进而提高系统的吞吐率
同时，将任务的提交和任务的执行策略分离，降低系统耦合性。
因此，我们可以在任务的执行策略方面做很多拓展，如
1. 采用何种顺序执行任务，如FIFO，LIFO，或者基于任务的优先级
2. 多少个任务可以并发执行
3. 多少个任务可以被排队等待执行
4. 如果有任务由于系统过载被拒绝，此时哪个任务该被舍弃，应用程序如何被通知到
5. 任务执行前和执行后需要哪些操作


因为此模式会用到可控的无界队列或者有界队列，因此有必要对缓冲区进行监控

如果缓冲区饱和，此时可以使用JDK提供的策略实现来应对（ThreadPoolExecutor类中包含四种处理策略），即
1. ThreadPoolExecutor.AbortPolicy
2. ThreadPoolExecutor.DiscardPolicy
3. ThreadPoolExecutor.DiscardOldestPolicy
4. ThreadPoolExecutor.CallerRunsPolicy


由于使用到线程池，此时也有必要考虑清理空闲的线程以节约资源，因此，在初始化ThreadPoolExecutor实例时指定存活时间，这样当空闲的线程超过这个时间仍然没有任务要处理，则将它清理掉

 

参考资料

黄文海 Java多线程编程实战指南（设计模式篇）

黄文海的Github

 

 

布鲁斯1990
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程模式——Active Object(主动对象)模式
buyoufa的博客
07-09 1771
Active Object(主动对象)模式
java多线程设计模式详解(PDF及源码)
07-14
Phase Termination——快把玩具收拾好，去睡觉吧 第11章 Thread-Specific Storage——每个线程的保管箱 第12章 Active Object——接受异步消息的主动对象 总结 多线程程序设计的模式语言 附录A 练习问题的解答 附录B...
ACE主动对象模式
weixin_33958366的博客
05-04 89
主动对象模式用于降低方法执行和方法调用之间的耦合。该模式描述了另外一种更为透明的任务间通信方法。 传统上，所有的对象都是被动的代码段，对象中的代码是在对它发出方法调用的线程中执行的，当方法被调用时，调用线程将阻塞，直至调用结束。而主动对象却不一样。这些对象具有自己的命令执行线程，主动对象的方法将在自己的执行线程中执行，不会阻塞调用方法。 例如，设想对象"A"已在你的程序的main()函数中...
设计模式- 主动对象（Active Object）
11-25 4493
原标题：Active Object －An Object Behavioral Pattern for Concurrent Programming源文地址：http://www.cs.wustl.edu/~schmidt/PDF/Act-Obj.pdf译者：cuichaox@gmail.com译者注：1.    对象分为主动对象和被动对象，主动对象内部包含一个线程，可以自动完成动作或改变状态，而
主动对象（Active Object）：用于并发编程的对象行为模式
09-13 4015
最近在看 > 和 ACE 的源码，如果要深入理解 ACE，最好能结合 POSA2 >，但是此书中文版的翻译不佳，幸运的是，POSA2的大部分内容可以在 C++NP2 的翻译者马维达先生另一个翻译的技术文档 > 找到。本贴转自http://docs.huihoo.com/ace_tao/ACE-2002-12/Part-One/Chapter-6.htm主动对象（Active Object）：用于并
主动对象模式(Active Object pattern)
weixin_30416497的博客
05-15 309
摘 要 　 本论文描述主动对象（Active Object）模式。该模式使方法执行与方法调用去耦合，以简化对驻留在它自己的线程控制中的对象的同步访问。主动对象模式允许一或多个交错访问数据的独立执行的线程被建模为单个对象。这一并发模式能良好地适用于广泛的生产者/消费者和读者/作者应用类。该模式通常用于需要多线程服务器的分布式系统中。此外，客户应用，比如窗口系统和网络浏览器，采用主动对象来简化并发...
java8源码-GraphicMultiThreadDesignPattern:图解Java多线程设计模式
06-04
记录自己学习《图解Java多线程设计模式》这本书的全部过程 本书上传的所有代码都是可以运行的，在此附上本书源码地址： 在此向本书作者和译者表示感谢 运行环境 Eclipse版本：Oxygen.2 Release (4.7.2) JDK版本：jdk...
多线程单例模式并发访问
10-19
单例模式是一种常用的软件设计模式，用于确保一个类只有一个实例，并提供一个全局访问点。 - **饿汉式**：在类装载时即完成初始化，避免了线程同步的问题。 - **懒汉式**：通过静态内部类或者双重检查锁定的方式来...
java多线程设计模式 (PDF中文版, 附源码)
09-06
目录： 漫谈UML Introduction 1 Java语言的线程 Introduction 2 多线程...总结 多线程程序设计的模式语言 附录A 练习问题的解答 附录B Java的内存模型 附录C Java线程的优先级 附录D 线程相关的主要API 附录E 参考文献
多线程编程指南
06-15
### 多线程编程指南知识点概述 #### 一、多线程编程概念与术语 **1.1 什么是多线程** 多线程是指在单个进程中能够同时运行多个线程的技术。...此外，合理的设计和良好的编码习惯也是保证多线程程序质量的关键。
23种设计模式（C++）.PDF
11-21
c++设计模式，适合对设计架构有兴趣的人阅读，可以提升我们的设计思维
设计模式（九）主动对象模式
胜利者的经验并不复杂,那就是寻找人生的关键点,并在关键时刻竭尽全力
02-12 2175
1. 用到了command与proxy模式，变成了一个更强大的模式。 2. 一般的command模式是当有请求到来的时候，在主线程中（也可以是其他线程，主线程这里只表示上下文）生成一个command，然后push到命令池（并不是所有的都有命令池的，这也是主动对象不同的地方，主动对象都有单独线程，不是在当前上下文中执行），在命令池线程中执行execute方法，或者在主线程中直接调用exec
主动对象模式
最新发布
Physics_ITBoy的专栏
09-24 73
代理者被调用的时候会创建具体“调用请求”对象，对象中包含了执行这个方法必须的参数和数据的返回方式。对应的执行者的方法将被调用。对象分为主动对象和被动对象，主动对象内部包含一个线程，可以自动完成动作或改变状态，而一般的被动对象只能通过被其他对象调用才有所作为。调度的决定可能决定与多个规则：关键字顺序，入队的顺序，要满足的执行条件或等待发生的事件，如：在一个数据结构中出现空闲区。总的来说，主动对象模式的主要优点是能够提高系统的并发性，从而提高系统的吞吐率，适合于需要进行多线程处理和并发访问同一资源的场景。
ACE中的主动对象模式(Active Object Pattern)
ciahi的专栏
01-19 3255
被动对象就是一般情况下在那儿放着不会动，等待着别的执行线程调用，然后才会执行。主动对象一般自己包含执行线程，可以主动的执行代码。 1.主动对象是基于ACE_Task类的，它提供执行线程的。 2.当某些要执行的代码想被执行时，要放入某个队列，然后执行线程发现队列不空时就从这个队列里面取出这个队列中的对象，然后执行。这个队列就是ACE_Activation_Queue。 3.放
设计模式笔记：策略模式与创建型模式解析
不过，实现单例模式时需要注意多线程环境下的并发问题，例如同步方法可能导致效率下降，而“双重检查加锁”策略可以有效地解决这个问题。 在面向对象的设计原则中，封装变化是核心之一，意味着应将可能变化的部分...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值