《操作系统导论》第三十一章作业

最新推荐文章于 2022-05-22 12:52:11 发布
最新推荐文章于 2022-05-22 12:52:11 发布
阅读量868 收藏 4
点赞数 3
分类专栏： 操作系统导论作业 文章标签： 经验分享
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sfadjlha/article/details/124879549
版权

第一题

在这里插入图片描述
这个问题是需要我们完善fork/join函数：

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include "common_threads.h"

sem_t s; 

void *child(void *arg) {
    printf("child\n");
    // use semaphore here
    return NULL;
}

int main(int argc, char *argv[]) {
    pthread_t p;
    printf("parent: begin\n");
    // init semaphore here
    Pthread_create(&p, NULL, child, NULL);
    // use semaphore here
    printf("parent: end\n");
    return 0;
}

要求按顺序打印：
parent:begin
child
parent:end
补全如下：

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include "common_threads.h"

sem_t s; 

void *child(void *arg) {
sleep(1);
    printf("child\n");
    sem_post(&s);
    // use semaphore here
    return NULL;
}

int main(int argc, char *argv[]) {
    pthread_t p;
    printf("parent: begin\n");
    // init semaphore here
    sem_init(&s,0,0);
    Pthread_create(&p, NULL, child, NULL);
    // use semaphore here
    sem_wait(&s);
    printf("parent: end\n");
    return 0;
}

补全后的代码如上，在child函数中的刚开始部分加上了sleep（1），同时初始化了信号量，如果父进程先到达，父进程被停止在了sem_wait的位置，等待子进程的完成。所以会输出我们所需要的结果。编译代码并且运行，最后的与逆行结果为：
在这里插入图片描述

第二题

在这里插入图片描述
rendezvous.c的代码如下：

#include <stdio.h>
#include <unistd.h>
#include "common_threads.h"

// If done correctly, each child should print their "before" message
// before either prints their "after" message. Test by adding sleep(1)
// calls in various locations.

sem_t s1, s2;

void *child_1(void *arg) {
    printf("child 1: before\n");
    // what goes here?
    printf("child 1: after\n");
    return NULL;
}

void *child_2(void *arg) {
    printf("child 2: before\n");
    // what goes here?
    printf("child 2: after\n");
    return NULL;
}

int main(int argc, char *argv[]) {
    pthread_t p1, p2;
    printf("parent: begin\n");
    // init semaphores here
    Pthread_create(&p1, NULL, child_1, NULL);
    Pthread_create(&p2, NULL, child_2, NULL);
    Pthread_join(p1, NULL);
    Pthread_join(p2, NULL);
    printf("parent: end\n");
    return 0;
}

根据注释，我们知道我们需要先打印出两个before，然后再输出两个after；
所以补全代码如下：

#include <stdio.h>
#include <unistd.h>
#include "common_threads.h"

// If done correctly, each child should print their "before" message
// before either prints their "after" message. Test by adding sleep(1)
// calls in various locations.

sem_t s1, s2;

void *child_1(void *arg) {
    printf("child 1: before\n");
    sem_post(&s2);
    sem_wait(&s1);
    // what goes here?
    printf("child 1: after\n");
    return NULL;
}

void *child_2(void *arg) {
    printf("child 2: before\n");
    sem_post(&s1);
    sem_wait(&s2);
    // what goes here?
    printf("child 2: after\n");
    return NULL;
}

int main(int argc, char *argv[]) {
    pthread_t p1, p2;
    printf("parent: begin\n");
    // init semaphores here
    sem_init(&s1,0,0);
    sem_init(&s2,0,0);
    Pthread_create(&p1, NULL, child_1, NULL);
    Pthread_create(&p2, NULL, child_2, NULL);
    Pthread_join(p1, NULL);
    Pthread_join(p2, NULL);
    printf("parent: end\n");
    return 0;
}

这段代码使用了两个信号量，第一个进程输出完before之后，让该进程睡眠然后调用另一个进程，另一个进程输出完before之后，该进程睡眠，然后第一个进程继续运行。最后的运行结果如下，题中的要求相同：
在这里插入图片描述

第四题

在这里插入图片描述
reader-writer.c的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "common_threads.h"

//
// Your code goes in the structure and functions below
//

typedef struct __rwlock_t {
} rwlock_t;


void rwlock_init(rwlock_t *rw) {
}

void rwlock_acquire_readlock(rwlock_t *rw) {
}

void rwlock_release_readlock(rwlock_t *rw) {
}

void rwlock_acquire_writelock(rwlock_t *rw) {
}

void rwlock_release_writelock(rwlock_t *rw) {
}

//
// Don't change the code below (just use it!)
// 

int loops;
int value = 0;

rwlock_t lock;

void *reader(void *arg) {
    int i;
    for (i = 0; i < loops; i++) {
	rwlock_acquire_readlock(&lock);
	printf("read %d\n", value);
	rwlock_release_readlock(&lock);
    }
    return NULL;
}

void *writer(void *arg) {
    int i;
    for (i = 0; i < loops; i++) {
	rwlock_acquire_writelock(&lock);
	value++;
	printf("write %d\n", value);
	rwlock_release_writelock(&lock);
    }
    return NULL;
}

int main(int argc, char *argv[]) {
    assert(argc == 4);
    int num_readers = atoi(argv[1]);
    int num_writers = atoi(argv[2]);
    loops = atoi(argv[3]);

    pthread_t pr[num_readers], pw[num_writers];

    rwlock_init(&lock);

    printf("begin\n");

    int i;
    for (i = 0; i < num_readers; i++)
	Pthread_create(&pr[i], NULL, reader, NULL);
    for (i = 0; i < num_writers; i++)
	Pthread_create(&pw[i], NULL, writer, NULL);

    for (i = 0; i < num_readers; i++)
	Pthread_join(pr[i], NULL);
    for (i = 0; i < num_writers; i++)
	Pthread_join(pw[i], NULL);

    printf("end: value %d\n", value);

    return 0;
}

代码的完善如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "common_threads.h"

//
// Your code goes in the structure and functions below
//

typedef struct __rwlock_t {
  sem_t lock;
  sem_t write_lock;
  int reader_number;
} rwlock_t;


void rwlock_init(rwlock_t *rw) {
     sem_init(&rw->lock,0,1);
     sem_init(&rw->write_lock,0,1);
     rw->reader_number=0;
}

void rwlock_acquire_readlock(rwlock_t *rw) {
    sleep(1);
    sem_wait(&rw->lock);
    rw->reader_number++;
    if(rw->reader_number==1)
      {sem_wait=(&rw->write_lock);
}
sem_post(&rw->lock);
}

void rwlock_release_readlock(rwlock_t *rw) {
sem_wait(&rw->lock);
rw->reader_number--;
if(rw->reader_number==0)
{
sem_post(&rw->write_lock);
}
sem_post(&rw->lock);
}

void rwlock_acquire_writelock(rwlock_t *rw) {
sleep(1);
sem_wait(&rw->write_lock);
}

void rwlock_release_writelock(rwlock_t *rw) {
sem_post(&rw->write_lock);
}

//
// Don't change the code below (just use it!)
// 

int loops;
int value = 0;

rwlock_t lock;

void *reader(void *arg) {
    int i;
    for (i = 0; i < loops; i++) {
	rwlock_acquire_readlock(&lock);
	printf("read %d\n", value);
	rwlock_release_readlock(&lock);
    }
    return NULL;
}

void *writer(void *arg) {
    int i;
    for (i = 0; i < loops; i++) {
	rwlock_acquire_writelock(&lock);
	value++;
	printf("write %d\n", value);
	rwlock_release_writelock(&lock);
    }
    return NULL;
}

int main(int argc, char *argv[]) {
    assert(argc == 4);
    int num_readers = atoi(argv[1]);
    int num_writers = atoi(argv[2]);
    loops = atoi(argv[3]);

    pthread_t pr[num_readers], pw[num_writers];

    rwlock_init(&lock);

    printf("begin\n");

    int i;
    for (i = 0; i < num_readers; i++)
	Pthread_create(&pr[i], NULL, reader, NULL);
    for (i = 0; i < num_writers; i++)
	Pthread_create(&pw[i], NULL, writer, NULL);

    for (i = 0; i < num_readers; i++)
	Pthread_join(pr[i], NULL);
    for (i = 0; i < num_writers; i++)
	Pthread_join(pw[i], NULL);

    printf("end: value %d\n", value);

    return 0;
}

我们只需要将读者的数量设置的很大，写者就需要等待读者全部被释放之后，才能写，所以当数量很大时，可能会出现写者的饥饿问题。
输入指令：./reader-writer 5 5 10

程序三个参数分别为读者数，写者数，每个读者、写者进行的读写操作数

运行结果如下：

zhaolv@ubuntu:~/ostep-homework/threads-sema$ ./reader-writer  5 5 10
begin
read 0
read 0
read 0
read 0
read 0
write 1
write 2
write 3
write 4
write 5
read 5
write 6
write 7
read 7
write 8
read 8
read 8
read 8
write 9
write 10
write 11
write 12
read 12
read 12
write 13
read 13
read 13
read 13
write 14
write 15
write 16
write 17
read 17
read 17
write 18
read 18
read 18
read 18
write 19
write 20
read 20
write 21
write 22
read 22
write 23
read 23
read 23
read 23
write 24
write 25
write 26
write 27
read 27
read 27
write 28
read 28
read 28
read 28
write 29
write 30
write 31
read 31
read 31
write 32
write 33
read 33
read 33
read 33
write 34
write 35
read 35
read 35
write 36
write 37
write 38
read 38
read 38
read 38
write 39
write 40
read 40
write 41
write 42
read 42
write 43
read 43
read 43
read 43
write 44
write 45
write 46
write 47
read 47
read 47
write 48
read 48
read 48
read 48
write 49
write 50
end: value 50

第五题

在这里插入图片描述
reader-writer-nostarve.c的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include "common_threads.h"

//
// Here, you have to write (almost) ALL the code. Oh no!
// How can you show that a thread does not starve
// when attempting to acquire this mutex you build?
//

typedef __ns_mutex_t {
} ns_mutex_t;

void ns_mutex_init(ns_mutex_t *m) {
}

void ns_mutex_acquire(ns_mutex_t *m) {
}

void ns_mutex_release(ns_mutex_t *m) {
}


void *worker(void *arg) {
    return NULL;
}

int main(int argc, char *argv[]) {
    printf("parent: begin\n");
    printf("parent: end\n");
    return 0;
}

这里需要生产者和消费者都要运行，我们同时看到第六题需要构建一个没有饥饿的互斥量，但是这里只需要两个都运行就可以满足。所以这里我们可以设置一个写锁，第一个读者会获得写锁，接下来的读者都可以获得读锁，但是写者则不能进入，只有等到所有的读者都结束，写者才能获得写锁。
所以，这里可以补全代码为：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "common_threads.h"

//
// Your code goes in the structure and functions below
//

typedef struct __rwlock_t {
sem_t lock;
sem_t write_lock;
sem_t write_waiting;
int reader_number;
} rwlock_t;


void rwlock_init(rwlock_t *rw) {
sem_init(&rw->lock,0,1);
sem_init(&rw->write_lock,0,1);
sem_init(&rw->write_waiting,0,1);
rw->reader_number=0;
}

void rwlock_acquire_readlock(rwlock_t *rw) {
sleep(1);
sem_wait(&rw->write_waiting);
sem_wait(&rw->lock);
rw->reader_number++;
if(rw->reader_number==1)
{
sem_wait(&rw->write_lock);
}
sem_post(&rw->lock);
sem_post(&rw->write_waiting);
}

void rwlock_release_readlock(rwlock_t *rw) {
sem_wait(&rw->lock);
rw->reader_number--;
if(rw->reader_number==0)
{
sem_post(&rw->write_lock);
}
}

void rwlock_acquire_writelock(rwlock_t *rw) {
sleep(1);
sem_wait(&rw->write_waiting);
sem_wait(&rw->write_lock);
sem_post(&rw->write_waiting);
}

void rwlock_release_writelock(rwlock_t *rw) {
sem_post(&rw->write_lock);
}

//
// Don't change the code below (just use it!)
// 

int loops;
int value = 0;

rwlock_t lock;

void *reader(void *arg) {
    int i;
    for (i = 0; i < loops; i++) {
	rwlock_acquire_readlock(&lock);
	printf("read %d\n", value);
	rwlock_release_readlock(&lock);
    }
    return NULL;
}

void *writer(void *arg) {
    int i;
    for (i = 0; i < loops; i++) {
	rwlock_acquire_writelock(&lock);
	value++;
	printf("write %d\n", value);
	rwlock_release_writelock(&lock);
    }
    return NULL;
}

int main(int argc, char *argv[]) {
    assert(argc == 4);
    int num_readers = atoi(argv[1]);
    int num_writers = atoi(argv[2]);
    loops = atoi(argv[3]);

    pthread_t pr[num_readers], pw[num_writers];

    rwlock_init(&lock);

    printf("begin\n");

    int i;
    for (i = 0; i < num_readers; i++)
	Pthread_create(&pr[i], NULL, reader, NULL);
    for (i = 0; i < num_writers; i++)
	Pthread_create(&pw[i], NULL, writer, NULL);

    for (i = 0; i < num_readers; i++)
	Pthread_join(pr[i], NULL);
    for (i = 0; i < num_writers; i++)
	Pthread_join(pw[i], NULL);

    printf("end: value %d\n", value);

    return 0;
}

运行结果如下：

zhaolv@ubuntu:~/ostep-homework/threads-sema$ gcc -o reader-writer-nostarve reader-writer-nostarve.c -Wall -pthread
zhaolv@ubuntu:~/ostep-homework/threads-sema$ ./reader-writer-nostarve  5 5 10
begin
read 0
read 0
read 0
read 0
read 0
write 1
write 2
write 3
write 4
write 5
read 5
read 5
read 5
read 5
read 5
write 6
write 7
write 8
write 9
write 10
read 10
read 10
read 10
read 10
read 10
write 11
write 12
write 13
write 14
write 15
read 15
read 15
read 15
read 15
read 15
write 16
write 17
write 18
write 19
write 20
read 20
read 20
read 20
read 20
read 20
write 21
write 22
write 23
write 24
write 25
read 25
read 25
read 25
read 25
read 25
write 26
write 27
write 28
write 29
write 30
read 30
read 30
read 30
read 30
write 31
write 32
read 32
write 33
write 34
write 35
read 35
read 35
read 35
read 35
write 36
write 37
read 37
write 38
write 39
write 40
read 40
read 40
read 40
write 41
read 41
write 42
read 42
write 43
write 44
write 45
read 45
read 45
write 46
read 46
write 47
read 47
write 48
write 49
read 49
write 50
end: value 50

可以看到read和write都在运行。

第六题

在这里插入图片描述
mutex-nostrave.c的代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include "common_threads.h"

//
// Here, you have to write (almost) ALL the code. Oh no!
// How can you show that a thread does not starve
// when attempting to acquire this mutex you build?
//

typedef __ns_mutex_t {
} ns_mutex_t;

void ns_mutex_init(ns_mutex_t *m) {
}

void ns_mutex_acquire(ns_mutex_t *m) {
}

void ns_mutex_release(ns_mutex_t *m) {
}


void *worker(void *arg) {
    return NULL;
}

int main(int argc, char *argv[]) {
    printf("parent: begin\n");
    printf("parent: end\n");
    return 0;
}

这里可以判断是否所有的进程都已经运行过了，之后再往后执行。
代码完善如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include "common_threads.h"

//
// Here, you have to write (almost) ALL the code. Oh no!
// How can you show that a thread does not starve
// when attempting to acquire this mutex you build?
//

typedef __ns_mutex_t {
sem_t mutex;
sem_t barrier;
sem_t lock;
int num_threads;
} ns_mutex_t;

void ns_mutex_init(ns_mutex_t *m) {
sem_init(&m->barrier,0,-num_threads+1);
sem_init(&m->mutex,0,1);
}

void ns_mutex_acquire(ns_mutex_t *m) {
sem_wait(&m->lock);
}

void ns_mutex_release(ns_mutex_t *m) {
sem_post(&m->lock);
sem_post(&m->barrier);
sem_wait(&m->barrier);
sem_wait(&m->mutex);
for(int i=0;i<m->num_threads;i++)
{
sem_post(&m->barrier);
}
sem_post(&m->mutex);
}


void *worker(void *arg) {
    return NULL;
}

int main(int argc, char *argv[]) {
    printf("parent: begin\n");
    printf("parent: end\n");
    return 0;
}
湖大
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
操作系统第三十一章作业（1-2，4-6题）
LoveMQ_919的博客
12-21 1976
操作系统第三十一章作业（1-2，4-6题） 所有题目均为自己所作，答案仅供参考，禁止抄袭 觉得有用可赏个赞，有不对之处欢迎评论指正 第一题 The first problem is just to implement and test a solution to the fork/join problem, as described in the text. Even though this s...
操作系统导论第31章——信号量
crazyfox的博客
08-22 450
1. 定义 一种同步原语，可以用它实现锁和条件变量 初始化： #include <semaphore.h> sem_t s; sem_init(&s, 0, 1) 第二个参数表示信号量的指针，第二个参数0表示信号量是在同一个进程的多个线程共享的，第三个参数是信号量的初始值 sem_wait int sem_wait(sem_t* s) { 1.信号量减1 2.若信号量为负则等待 } sem_post int sem_post(sem_t* s) ..
《操作系统导论》第31章课后答案
jzb的博客
05-22 760
31.1 问题描述： 第一个问题就是实现和测试 fork/join 问题的解决方案，如本文所述。 即使在文本中描述了此解决方案， 重新自己实现一遍也是值得的。 even Bach would rewrite Vivaldi， allowing one soon-to-be master to learn from an existing one。 有关详细信息，请参见 fork-join.c。 将添加 sleep(1) 到 child 函数内以确保其正常工作。 解答： 题目要求我们补全fork-join.c
linux下C++线程的使用
qq_44771537的博客
02-25 2649
一、 创建线程 在Linux下，采用pthread_create函数来创建一个新的线程 语法： #include <pthread.h> int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg); thread：指向线程标识符的地址。 attr：用于设置线程属性，一般为null，表示使
多线程例程
u011356503的博客
04-11 217
1.子线程循环10次，主线程循环100次，接着子线程循环10次，如此循环50次，请写出代码 #include <stdlib.h> #include <stdio.h> #include <pthread.h> #include <unistd.h> #define LOOPNUM 50 #define MAINLOOPNUM 100 #de...
历年考点-操作系统复习提纲1
08-08
第三章：进程 进程是系统中执行的程序实例，包含程序状态和资源分配。进程调度决定哪个进程获得CPU执行，进程操作涉及挂起、唤醒、终止等。进程通信用于进程间的信息交换，有管道、消息队列、共享内存等多种方式。...
北师大《计算机导论》在线作业.docx
最新发布
05-23
Mac OS是一个（ ） 搜索引擎 浏览器 操作系统 聊天工具 单选：第8题（2.5分） 有关防火墙的作用下列说法正确的是（ ） 北师大《计算机导论》在线作业全文共12页，当前为第3页。北师大《计算机导论》在线作业全文共12...
21春南开大学《物联网工程导论》在线作业参考答案.docx
10-23
"21春南开大学《物联网工程导论》在线作业参考答案" 本资源为南开大学《物联网工程导论》在线作业参考答案，涵盖了物联网工程导论的基本概念、技术和应用。下面是对题目中出现的知识点的详细解释： 1. 声纳是一种...
北师大0495《计算机导论》在线作业.doc
05-23
0495北师大《计算机导论》在线作业 "大规模集成电路是〔 的特征 " "第一代计算机 " "第二代计算机 " "第三代计算机 " "第四代计算机 " "计算机指令的操作码是用来〔 " "规定指令进行的操作种类 " "给出操作数地址 " ...
计算机科学导论历年在线作业含.pdf
10-06
2. **CPU调度策略**：批处理不是CPU调度的策略，它是指操作系统一次性提交多个作业，让它们在后台运行。 3. **内存历史**：内存的概念首次出现在查尔斯·巴贝奇的分析机中，这是早期的机械式通用计算机概念。 4. *...
线程的创建及运行
welcome to 浩·C's blog
05-30 292
#include #include #include void* thread_main(void*); int main() { pthread_t t_id; int thread_param=5; if(pthread_create(&t_id,NULL,thread_main,&thread_param)!=0) { puts("pthread_create() e
Linux线程编程（二）
qq_42882082的博客
06-07 542
二、线程相关API 注： 与线程有关的函数构成了一个完整的系列，绝大多数函数的名字都是以pthread_d打头的，要使用这些函数库，要通过引入头文件pthread.h，因为pthread的库不是linux系统的库，所以在进行编译的时候要加上-lpthread进行链接线程函数库。 同进程ID一样，线程ID是pid_t类型的变量，而且是用来唯一标识线程的一个整型变量，在linux当中如果你要查询系统中的线程，也有一条命令：ps -aL 在传统的UNIX进程模型中，每个进程只有一个控制线程，从概念上讲，这与基于
Linux下各种锁地理解和使用以及总结解决一下epoll惊群问题(面试常考)
小杰312的博客
03-16 5367
Linux下各种锁地理解和使用以及总结解决一下epoll惊群问题(面试常考)
Linux多线程编程
长期更新Java自学笔记
01-06 2042
线程同步： 多线程环境中，无论调度顺序怎么样，都能得到我们想要的结果 同步的方法： 信号量、互斥锁、条件变量、读写锁 互斥锁只能用于互斥型场景，它的作用等同于二值（0/1）信号量的作用 pthread_create：创建并启动线程 pthread_exit：退出线程 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <pthre
Linux进程控制
weixin_44395170的博客
11-05 149
学习进程创建, 等待, 终止. 使用代码实现. 编写自主shell. 封装fork/wait等操作, 编写函数 process_create(pid_t* pid, void* func, void* arg), func回调函数就是子进程执行的入口函数, arg是传递给func回调函数的参数. 调研popen/system, 理解这两个函数和fork的区别. ...
信号量解决生产者-消费者问题
qzk1993的博客
08-12 1383
信号量 生产者-消费者问题
在linux虚拟机下线程pthread_create未定义的引用问题
coddingStartting的博客
04-22 685
代码为： #include <stdio.h> #include <string.h> #include <pthread.h>//for thread #include <stdlib.h> #include <unistd.h> pthread_t tid[2];//make two threads void* doSomeTh...
pthread编程基础
dsg333的专栏
09-13 1331
http://blog.chinaunix.net/uid-20528014-id-333508.html Linux系统下的多线程遵循POSIX线程接口，称为pthread。编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。与vxworks上任务的概念类似，都是调度的最小单元，都有共享的堆、栈、代码区、全局变量等。   2.   
linux中pthread编程学习
weixin_44176506的博客
03-31 239
线程创建等待及退出 #include<stdio.h> #include<pthread.h> // int pthread_create(pthread_t *thread, const pthread_attr_t *attr, // void *(*start_routine) (void *), void *arg); void * func1(void *arg) { static ch
UNIT1操作系统导论讲义课程.pptx
04-26
UNIT1操作系统导论讲义课程.

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值