Libevent 官方文档英文 intro - 1 总结

最新推荐文章于 2023-12-16 15:59:36 发布
最新推荐文章于 2023-12-16 15:59:36 发布
阅读量188 收藏
点赞数
分类专栏： Libevent
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdoyuxuan/article/details/79651234
版权
阻塞I/O

  Linux下的默认socket都是阻塞文件描述符，那么我们写网络程序的所有调用函数，都是阻塞的这样性能十分之低。
  最主要的问题是，如果可能同时有多个连接到来的时候，阻塞I/O根本无法正常工作

/* This won't work. */
char buf[1024];
int i, n;
while (i_still_want_to_read()) {
    for (i=0; i<n_sockets; ++i) {
        n = recv(fd[i], buf, sizeof(buf), 0);
        if (n==0)
            handle_close(fd[i]);
        else if (n<0)
            handle_error(fd[i], errno);
        else
            handle_input(fd[i], buf, n);
    }
}

  在上面这个列子中，即使fd[2]的连接到来，我们也无法处理，直到 fd[0] ,fd[1]连接处理后，才能处理fd[2]，所以阻塞在这种场景根本无法工作
  那么为了处理这个问题。现在有俩张方案，一个是单进程/线程的 多路复用来处理，一种是多线程/多进程程序来处理，每一个线程/进程处理一个连接。

多线程/多进程处理方案

  多进程和多线程在大多数平台下开销很大，无论申请还是上下文切换。所以我们可能有的时候使用线程池来解决，可线程池治标不治本，当同时并发数万个连接的时候，效率就太低了，因为真正工作的线程就是每个cpu上的线程。

非阻塞处理方案
int i, n;
char buf[1024];
for (i=0; i < n_sockets; ++i)
    fcntl(fd[i], F_SETFL, O_NONBLOCK);

while (i_still_want_to_read()) {
    for (i=0; i < n_sockets; ++i) {
        n = recv(fd[i], buf, sizeof(buf), 0);
        if (n == 0) {
            handle_close(fd[i]);
        } else if (n < 0) {
            if (errno == EAGAIN)
                 ; /* The kernel didn't have any data for us to read. */
            else
                 handle_error(fd[i], errno);
         } else {
            handle_input(fd[i], buf, n);
         }
    }
}

  虽然是非阻塞，但是这个性能很差，有来个原因。

  1. 没有数据到达时，它不会不停的自旋轮询，浪费CPU时间片。
  2. 如果要处理多个连接的时候，无论是否有数据，每次recv的时候都会陷入系统调用，这个也是一种浪费。
      那么这样，我们就希望只有当 数据到达的时候，I/O条件就绪的时候I/O，那么就引来了多路复用。
多路复用select
/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For fcntl */
#include <fcntl.h>
/* for select */
#include <sys/select.h>

#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#define MAX_LINE 16384

char
rot13_char(char c)
{
    /* We don't want to use isalpha here; setting the locale would change
     * which characters are considered alphabetical. */
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

struct fd_state {
    char buffer[MAX_LINE];
    size_t buffer_used;

    int writing;
    size_t n_written;
    size_t write_upto;
};

struct fd_state *
alloc_fd_state(void)
{
    struct fd_state *state = malloc(sizeof(struct fd_state));
    if (!state)
        return NULL;
    state->buffer_used = state->n_written = state->writing =
        state->write_upto = 0;
    return state;
}

void
free_fd_state(struct fd_state *state)
{
    free(state);
}

void
make_nonblocking(int fd)
{
    fcntl(fd, F_SETFL, O_NONBLOCK);
}

int
do_read(int fd, struct fd_state *state)
{
    char buf[1024];
    int i;
    ssize_t result;
    while (1) {
        result = recv(fd, buf, sizeof(buf), 0);
        if (result <= 0)
            break;

        for (i=0; i < result; ++i)  {
            if (state->buffer_used < sizeof(state->buffer))
                state->buffer[state->buffer_used++] = rot13_char(buf[i]);
            if (buf[i] == '\n') {
                state->writing = 1;
                state->write_upto = state->buffer_used;
            }
        }
    }

    if (result == 0) {
        return 1;
    } else if (result < 0) {
        if (errno == EAGAIN)
            return 0;
        return -1;
    }

    return 0;
}

int
do_write(int fd, struct fd_state *state)
{
    while (state->n_written < state->write_upto) {
        ssize_t result = send(fd, state->buffer + state->n_written,
                              state->write_upto - state->n_written, 0);
        if (result < 0) {
            if (errno == EAGAIN)
                return 0;
            return -1;
        }
        assert(result != 0);

        state->n_written += result;
    }

    if (state->n_written == state->buffer_used)
        state->n_written = state->write_upto = state->buffer_used = 0;

    state->writing = 0;

    return 0;
}

void
run(void)
{
    int listener;
    struct fd_state *state[FD_SETSIZE];
    struct sockaddr_in sin;
    int i, maxfd;
    fd_set readset, writeset, exset;

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(40713);

    for (i = 0; i < FD_SETSIZE; ++i)
        state[i] = NULL;

    listener = socket(AF_INET, SOCK_STREAM, 0);
    make_nonblocking(listener);

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        perror("bind");
        return;
    }

    if (listen(listener, 16)<0) {
        perror("listen");
        return;
    }

    FD_ZERO(&readset);
    FD_ZERO(&writeset);
    FD_ZERO(&exset);

    while (1) {
        maxfd = listener;

        FD_ZERO(&readset);
        FD_ZERO(&writeset);
        FD_ZERO(&exset);

        FD_SET(listener, &readset);

        for (i=0; i < FD_SETSIZE; ++i) {
            if (state[i]) {
                if (i > maxfd)
                    maxfd = i;
                FD_SET(i, &readset);
                if (state[i]->writing) {
                    FD_SET(i, &writeset);
                }
            }
        }

        if (select(maxfd+1, &readset, &writeset, &exset, NULL) < 0) {
            perror("select");
            return;
        }

        if (FD_ISSET(listener, &readset)) {
            struct sockaddr_storage ss;
            socklen_t slen = sizeof(ss);
            int fd = accept(listener, (struct sockaddr*)&ss, &slen);
            if (fd < 0) {
                perror("accept");
            } else if (fd > FD_SETSIZE) {
                close(fd);
            } else {
                make_nonblocking(fd);
                state[fd] = alloc_fd_state();
                assert(state[fd]);/*XXX*/
            }
        }

        for (i=0; i < maxfd+1; ++i) {
            int r = 0;
            if (i == listener)
                continue;

            if (FD_ISSET(i, &readset)) {
                r = do_read(i, state[i]);
            }
            if (r == 0 && FD_ISSET(i, &writeset)) {
                r = do_write(i, state[i]);
            }
            if (r) {
                free_fd_state(state[i]);
                state[i] = NULL;
                close(i);
            }
        }
    }
}

int
main(int c, char **v)
{
    setvbuf(stdout, NULL, _IONBF, 0);

    run();
    return 0;
}

  如上代码列子，虽然解决了无故的系统调用，但是还是没有解决轮询开销。如果只想处理少许的连接这个表现很好，但是当连接过多，select性能就会很差。
  用户层面的开销可能就是要遍历你自己往select中插入文件描述符的数组，而内核的开销却要遍历最大的文件描述符，这可能接近于整个 fd_set 的集合。可能你只往select注册了10个文件描述符，但是最大的文件描述符是4095，内核遍历的时候要遍历4095个文描。
  故不同平台下都有代替select的函数 , epoll , poll , kqueue 。所以 Libevent 跨平台很好，我们使用它就就可以使用这些替代函数了。

Libevent解决方案
/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For fcntl */
#include <fcntl.h>

#include <event2/event.h>

#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#define MAX_LINE 16384

void do_read(evutil_socket_t fd, short events, void *arg);
void do_write(evutil_socket_t fd, short events, void *arg);

char
rot13_char(char c)
{
    /* We don't want to use isalpha here; setting the locale would change
     * which characters are considered alphabetical. */
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

struct fd_state {
    char buffer[MAX_LINE];
    size_t buffer_used;

    size_t n_written;
    size_t write_upto;

    struct event *read_event;
    struct event *write_event;
};

struct fd_state *
alloc_fd_state(struct event_base *base, evutil_socket_t fd)
{
    struct fd_state *state = malloc(sizeof(struct fd_state));
    if (!state)
        return NULL;
    state->read_event = event_new(base, fd, EV_READ|EV_PERSIST, do_read, state);
    if (!state->read_event) {
        free(state);
        return NULL;
    }
    state->write_event =
        event_new(base, fd, EV_WRITE|EV_PERSIST, do_write, state);

    if (!state->write_event) {
        event_free(state->read_event);
        free(state);
        return NULL;
    }

    state->buffer_used = state->n_written = state->write_upto = 0;

    assert(state->write_event);
    return state;
}

void
free_fd_state(struct fd_state *state)
{
    event_free(state->read_event);
    event_free(state->write_event);
    free(state);
}

void
do_read(evutil_socket_t fd, short events, void *arg)
{
    struct fd_state *state = arg;
    char buf[1024];
    int i;
    ssize_t result;
    while (1) {
        assert(state->write_event);
        result = recv(fd, buf, sizeof(buf), 0);
        if (result <= 0)
            break;

        for (i=0; i < result; ++i)  {
            if (state->buffer_used < sizeof(state->buffer))
                state->buffer[state->buffer_used++] = rot13_char(buf[i]);
            if (buf[i] == '\n') {
                assert(state->write_event);
                event_add(state->write_event, NULL);
                state->write_upto = state->buffer_used;
            }
        }
    }

    if (result == 0) {
        free_fd_state(state);
    } else if (result < 0) {
        if (errno == EAGAIN) // XXXX use evutil macro
            return;
        perror("recv");
        free_fd_state(state);
    }
}

void
do_write(evutil_socket_t fd, short events, void *arg)
{
    struct fd_state *state = arg;

    while (state->n_written < state->write_upto) {
        ssize_t result = send(fd, state->buffer + state->n_written,
                              state->write_upto - state->n_written, 0);
        if (result < 0) {
            if (errno == EAGAIN) // XXX use evutil macro
                return;
            free_fd_state(state);
            return;
        }
        assert(result != 0);

        state->n_written += result;
    }

    if (state->n_written == state->buffer_used)
        state->n_written = state->write_upto = state->buffer_used = 1;

    event_del(state->write_event);
}

void
do_accept(evutil_socket_t listener, short event, void *arg)
{
    struct event_base *base = arg;
    struct sockaddr_storage ss;
    socklen_t slen = sizeof(ss);
    int fd = accept(listener, (struct sockaddr*)&ss, &slen);
    if (fd < 0) { // XXXX eagain??
        perror("accept");
    } else if (fd > FD_SETSIZE) {
        close(fd); // XXX replace all closes with EVUTIL_CLOSESOCKET */
    } else {
        struct fd_state *state;
        evutil_make_socket_nonblocking(fd);
        state = alloc_fd_state(base, fd);
        assert(state); /*XXX err*/
        assert(state->write_event);
        event_add(state->read_event, NULL);
    }
}

void
run(void)
{
    evutil_socket_t listener;
    struct sockaddr_in sin;
    struct event_base *base;
    struct event *listener_event;

    base = event_base_new();
    if (!base)
        return; /*XXXerr*/

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(40713);

    listener = socket(AF_INET, SOCK_STREAM, 0);
    evutil_make_socket_nonblocking(listener);

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        perror("bind");
        return;
    }

    if (listen(listener, 16)<0) {
        perror("listen");
        return;
    }
    listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept，
    (void*)base);
    event_add(listener_event, NULL);

    event_base_dispatch(base);
}

int
main(int c, char **v)
{
    setvbuf(stdout, NULL, _IONBF, 0);

    run();
    return 0;
}

  接下来就有俩个问题。

  1. 我们在堆上申请内存，这样代码写起来看起来很麻烦使用buffer
  2. 如果是windows上 ， IOCP 这种异步接口更快 比 libevent用的多路复用接口。
buffer

  Libevent自带buffer,我们可以使用这个，然代码看起来更简单。

/* For sockaddr_in */
#include <netinet/in.h>
/* For socket functions */
#include <sys/socket.h>
/* For fcntl */
#include <fcntl.h>

#include <event2/event.h>
#include <event2/buffer.h>
#include <event2/bufferevent.h>

#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>

#define MAX_LINE 16384

void do_read(evutil_socket_t fd, short events, void *arg);
void do_write(evutil_socket_t fd, short events, void *arg);

char
rot13_char(char c)
{
    /* We don't want to use isalpha here; setting the locale would change
     * which characters are considered alphabetical. */
    if ((c >= 'a' && c <= 'm') || (c >= 'A' && c <= 'M'))
        return c + 13;
    else if ((c >= 'n' && c <= 'z') || (c >= 'N' && c <= 'Z'))
        return c - 13;
    else
        return c;
}

void
readcb(struct bufferevent *bev, void *ctx)
{
    struct evbuffer *input, *output;
    char *line;
    size_t n;
    int i;
    input = bufferevent_get_input(bev);
    output = bufferevent_get_output(bev);

    while ((line = evbuffer_readln(input, &n, EVBUFFER_EOL_LF))) {
        for (i = 0; i < n; ++i)
            line[i] = rot13_char(line[i]);
        evbuffer_add(output, line, n);
        evbuffer_add(output, "\n", 1);
        free(line);
    }

    if (evbuffer_get_length(input) >= MAX_LINE) {
        /* Too long; just process what there is and go on so that the buffer
         * doesn't grow infinitely long. */
        char buf[1024];
        while (evbuffer_get_length(input)) {
            int n = evbuffer_remove(input, buf, sizeof(buf));
            for (i = 0; i < n; ++i)
                buf[i] = rot13_char(buf[i]);
            evbuffer_add(output, buf, n);
        }
        evbuffer_add(output, "\n", 1);
    }
}

void
errorcb(struct bufferevent *bev, short error, void *ctx)
{
    if (error & BEV_EVENT_EOF) {
        /* connection has been closed, do any clean up here */
        /* ... */
    } else if (error & BEV_EVENT_ERROR) {
        /* check errno to see what error occurred */
        /* ... */
    } else if (error & BEV_EVENT_TIMEOUT) {
        /* must be a timeout event handle, handle it */
        /* ... */
    }
    bufferevent_free(bev);
}

void
do_accept(evutil_socket_t listener, short event, void *arg)
{
    struct event_base *base = arg;
    struct sockaddr_storage ss;
    socklen_t slen = sizeof(ss);
    int fd = accept(listener, (struct sockaddr*)&ss, &slen);
    if (fd < 0) {
        perror("accept");
    } else if (fd > FD_SETSIZE) {
        close(fd);
    } else {
        struct bufferevent *bev;
        evutil_make_socket_nonblocking(fd);
        bev = bufferevent_socket_new(base, fd, BEV_OPT_CLOSE_ON_FREE);
        bufferevent_setcb(bev, readcb, NULL, errorcb, NULL);
        bufferevent_setwatermark(bev, EV_READ, 0, MAX_LINE);
        bufferevent_enable(bev, EV_READ|EV_WRITE);
    }
}

void
run(void)
{
    evutil_socket_t listener;
    struct sockaddr_in sin;
    struct event_base *base;
    struct event *listener_event;

    base = event_base_new();
    if (!base)
        return; /*XXXerr*/

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = 0;
    sin.sin_port = htons(40713);

    listener = socket(AF_INET, SOCK_STREAM, 0);
    evutil_make_socket_nonblocking(listener);

#ifndef WIN32
    {
        int one = 1;
        setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
    }
#endif

    if (bind(listener, (struct sockaddr*)&sin, sizeof(sin)) < 0) {
        perror("bind");
        return;
    }

    if (listen(listener, 16)<0) {
        perror("listen");
        return;
    }

    listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);
    /*XXX check it */
    event_add(listener_event, NULL);

    event_base_dispatch(base);
}

int
main(int c, char **v)
{
    setvbuf(stdout, NULL, _IONBF, 0);

    run();
    return 0;
}
总结

  看完介绍，感觉libevent就是对不同平台下的高效的多路复用接口的一个封装。平台移植性高，虽然可能性能不是最优的，比如在windows下。

sdoyuxuan
关注
专栏目录
libevent官方文档英文版
02-18
libevent英文pdf文档，来自官方html的转患成pdf文件！
Libevent中英文文档地址
Kernight
07-31 697
英文文档地址：http://www.wangafu.net/~nickm/libevent-book/TOC.html中文文档地址：http://wenku.baidu.com/view/7fbf4461a98271fe910ef9ba.html?re=view
前端新手引导的简单实现【Intro.js插件】
qq_42961150的博客
09-09 2895
前言 Intro.js的官方文档：https://introjs.com/docs/getting-started/install 利用Intro.js实现一个简单的新手引导 效果： 实现步骤 1. 打开官网可以看到intall中有介绍。可以在桌面打开cmd使用npm install intro.js --save 命令下载相关的插件代码，然后在node_modules文件夹找到intro.js、introjs.css放到自己的项目文件夹中。 2. 引入项目中 例如： <html>
Linux c 开发 - libevent
热门推荐
自娱自乐的代码人
12-15 1万+
Libevent介绍 libevent是一个事件触发的网络库，适用于windows、linux、bsd等多种平台，内部使用select、epoll、kqueue等系统调用管理事件机制。著名分布式缓存软件memcached也是libevent based，而且libevent在使用上可以做到跨平台，而且根据libevent官方网站上公布的数据统计，似乎也有着非凡的性能。
Book: Programming with Libevent(1)--Learning Libevent
share something here
09-07 391
Book: Programming with LibeventChapter 0: About this document关于本文档关于示例的说明Chapter 1: A tiny introduction to asynchronous IO. Chapter 0: About this document http://www.wangafu.net/~nickm/libevent-book/00_about.html 这些文件版权所有 © 2009-2012 by Nick Mathewson，并在知识
Libevent 学习一：Libevent 源码编译
myw31415926的专栏
10-15 1672
Libevent 学习一：Libevent 源码编译
libevent入门教程
大草的博客
12-16 2117
libevent入门教程
libevent 使用
步步天明的专栏
02-19 314
利用libevent编写服务端程序，主要有3部分 //创建主通知链base 1.base = event_base_new();   //创建要监听的事件，并将其加入到主通知链中。 2.listener_event = event_new(base, listener, EV_READ|EV_PERSIST, do_accept, (void*)base);  
libevent入门介绍
weixin_30488085的博客
12-02 68
libevent是之前看到的一个别人推荐的清凉级网络库，我就想了解一下它。今天下载到了一个人写的剖析系列，从结构和源码方面进行了简要分析。只是这个分析文章是2010年的，有点过时了（跟现在的libevent不太相符）。不过看看也好，毕竟模型、原理大部分相同的：http://pan.baidu.com/s/1hqgRJ1M 附官方文档教程：http://www.wangafu.net/~nickm/...
libevent官方文档 Ref1-9
02-08
《libevent官方文档详解》 libevent是一个高度可移植、高性能的事件通知库，它使得开发者可以编写出高效的网络服务器，处理并发I/O操作。这个文档集合包含了Ref1到Ref9，涵盖了libevent的核心概念、使用方法以及...
libevent-devel-2.0.21-4.el7.x86_64.rpm
01-12
1. **事件通知机制**：libevent使用内核的epoll（在Linux下）或者其他类似机制，监控多个文件描述符的状态变化，当某个描述符准备就绪时，libevent会通知应用程序。 2. **多种事件模型**：libevent支持多种事件模型...
libevent.zip libevent-2.1.10-stable.tar libevent-release-1.4.15-stable.tar
06-19
libevent-2.1.10-stable.tar libevent-release-1.4.15-stable.tar libevent文件组织 用50个金币买的，不想让继续多赚 包含这些
libevent-devel-2.0.21-4.el7.i686.rpm
12-11
官方离线安装包，亲测可用
libevent-thread-20140224-1.7z
10-28
《深入理解Libevent多线程机制：以libevent-thread-20140224-1源码为例》 Libevent是一个强大的事件通知库，它允许程序员在多个平台上高效地处理网络事件，如TCP、UDP、Unix域套接字等。在单线程环境中，Libevent...
Spring关于线程池和定时任务的英文官方文档摘录
zhy1008611的博客
12-08 3147
34. Task Execution and Scheduling 34.1 Introduction The Spring Framework provides abstractions for asynchronous execution and scheduling oftasks with the TaskExecutor and TaskScheduler inte
event_base
我喜欢雨天的清新的博客
08-10 3147
event_base 介绍   一个event_base就是一个Reactor框架。我们在调用任何Libevent的函数前，我们都是需要先申请 event_base 结构体。对于一个event_base结构来说，它会保存一系列的event事件并且以轮训的方式去关注每一个事件，去查看哪一个事件是就绪的。（事件就绪可以从unp第6章 I/O模型中有讲到）   如果一个 event_base设置了使...
BufferEvent
我喜欢雨天的清新的博客
08-13 3118
bufferevent   由于我们在网络通信中有很多输入输出的场景，所以Libevent也提供了相应的bufferevent。这些bufferevent由一个底层的传输对象(socket)，一个ReadBuufer，一个WriteBuffer构成。   与之前普通的event不同的是bufferevent只有当它的传输对象(fd)读取到了足够多的数据后才会调用它的回调函数。   buffe...
Evbuffer
我喜欢雨天的清新的博客
08-14 1113
Evbuffer   Evbuffer是用一个队列实现的，这个队列具有高效的尾插和头删。Evbuffer是用来提高网络 I/O的效率的一个工具，它的源码在 event2/buffer.h中。 创建或者释放一个evbuffer struct evbuffer *evbuffer_new(void); void evbuffer_free(struct evbuffer *buf); ...
libevent-pthreads-2.1-7 : Depends: libevent-core-2.1-7 (= 2.1.11-stable-1) but 2.1.12-stable-1build3 is to be installed
最新发布
09-21
这意味着如果你想继续使用 libevent-pthreads-2.1-7，你需要先卸载当前的 2.1.12-stable-1build3 并安装指定版本的 2.1.11-stable-1，以便满足libevent-pthreads-2.1-7 的依赖。 要解决这个问题，你可以按照以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值