Mit6.824-lab2a-2022

最新推荐文章于 2023-09-22 00:06:33 发布
最新推荐文章于 2023-09-22 00:06:33 发布
阅读量1k 收藏 2
点赞数
分类专栏： Mit6.824 文章标签： 服务器 javascript 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41703198/article/details/127089117
版权

Mit6.824-lab2a-2022

实验介绍

lab2总体是要复现一个简易的Raft系统，这个实验被分为了四个部分

  1. 2a ，Leader的选举与保持；
  2. 2b ，log的添加；
  3. 2c ，数据持久化与服务器恢复
  4. 2d ，snapshot实现

实验的重点是2a和2b，如果这两个部分没有打好基础，后面的实验会反复修改前面的代码，使得整个程序需要多次修改和调整，最后代码到处是corner case需要到处打补丁。

实验建议

1.熟悉整个实验

因此虽然实验要求是逐步推进，但是想要优雅的完成实验，建议在最一开始就反复通读Raft的paper和助教给的指导，让自己对整个实验有一个完整清晰的认识。

  1. Students’ Guide to Raft
  2. Raft的paper翻译
  3. Raft的可视化网站

一定要对原文第五章，Figure.2和第七章的内容都了然于心再进行代码工作，不然需要后期反复调整代码以及参数。尤其是Figure.2的处理步骤。此外需要熟悉官方提供给的一些工具代码。

2.提前做好后两个实验的准备

在进行2a和2b实验的时候，最好可以顾及到2c与2d的内容，主要是以下两个方面：

  1. 在需要数据持久化的地方添加persist()方法的调用
  2. 计算log和commit的下标时，直接使用已有snapshot的方式计算下标，而在测试时将snapshot的长度设为0

这样实验2c和2d可以节省很多时间

3.写好功能函数

如返回log的最后一个项目的Tern

// 返回全部log的最后一个的Term，包括snapshot
func (rf *Raft)LastTerm() int{
	lastTerm := 0
	if  len(rf.log) > 0{
		lastTerm = rf.log[len(rf.log)-1].Term
	}else if len(rf.log) == 0{
		lastTerm = rf.LastIncludedTerm
	}else{
		panic("term wrong,len(log) smaller than 0")
	}
	return lastTerm
}

这些功能函数在2d会有很大用处

4.做足够的测试

这里贴上官方的 测试代码，个人建议前一个实验可以保证1000次连续测试最多只有两到三个错误时再进行下一个，这时候应该还是某些地方有bug但是无伤大雅，而且这时候很难再进行进一步的debug。

但是注意 所有的bug都会累积到后面的实验中出现，而且后面实验更加复杂，更加难以找出bug，所以应该尽可能保证自己的代码逻辑无误，并且考虑到所有的corner case 然后再进行下一步实验，稳扎稳打，不然最后debug的过程漫长又痛苦

测试文件使用方法：放在raft文件夹下

./go-test-many.sh  [测试次数] [测试并行数]  [测试项目]
./go-test-many.sh  1000 5 2C //对2C实验测试1000次，五个并行测试
//测试项目可以是具体测试方法，在test_test.go内查看

2a实验内容

2a的实验内容很简单，复现raft leader选举和心跳(没有数据的 AppendEntries rpc请求)。这个lab2A的目标是选出leader，leader挂掉或者断网后新的leader上位。
同时要满足以下接口

// create a new Raft server instance:
func Make(peers []*labrpc.ClientEnd, me int,
	persister *Persister, applyCh chan ApplyMsg) *Raft

// start agreement on a new log entry:
func (rf *Raft) Start(command interface{}) (int, int, bool) 

// ask a Raft for its current term, and whether it thinks it is leader
func (rf *Raft) GetState() (int, bool)

按照Raft.go文件给出的结构，应该完成以下功能

  1. 一个计时器方法，用于判断server何时超时
  2. 选举方法
  3. server收到candidate的选举请求时回应
  4. 保持心跳

具体逻辑都应该严格参照论文Figure.2。首先测试代码通过make() 方法创建raft服务器，服务器等待超时后成为candidate，给所有其他raft服务器发送投票请求，通过则成为leader，此时不断给其他服务器发送空的log以保持心跳。
Figure2

具体实现

我2a的完整实现在 这里，但是需要指出，在这里的很多逻辑都是错误或者片面的，仅作为2a实验的实现，想要查看完整实现的可以查看该仓库的 raft.go。

  1. Make方法
func Make(peers []*labrpc.ClientEnd, me int,
	persister *Persister, applyCh chan ApplyMsg) *Raft {
	rf := &Raft{}
	rf.peers = peers
	rf.persister = persister
	rf.me = me

	// Your initialization code here (2A, 2B, 2C).

	rf.currentTerm = 0
	rf.votedFor = NILL
	rf.log = make([]Entry,1024)


	rf.commitIndex = 0
	rf.lastApplied = 0

	rf.nextIndex = make([]int,len(peers))
	rf.matchIndex = make([]int,len(peers))
	for i:=0;i<len(rf.peers);i++{
		rf.nextIndex[i] = 0;
		rf.matchIndex[i] = 0;
	}

	rf.state = Follower
	rf.candidateOut = 0
	rf.followerOut = 0


	rf.applyMessage = applyCh


	// initialize from state persisted before a crash
	rf.readPersist(persister.ReadRaftState())

	// start ticker goroutine to start elections
	go rf.Timer()


	return rf
}
  1. 计时器Timer
func (rf *Raft) Timer() {
	for {
		time.Sleep(time.Duration(100+rand.Intn(50)) * time.Millisecond)
		rf.mu.Lock()
		// Your code here to check if a leader election should
		// be started and to randomize sleeping time using
		// time.Sleep().
		if rf.killed(){
			rf.mu.Unlock()
			return
		}

		if rf.state == Leader || rf.state == Candidate{
			rf.mu.Unlock()
			continue
		}else if rf.state == Follower{
			rf.followerOut += 1
			if rf.followerOut >= FTimeOut{
				rf.followerOut = 0
				rf.state = Candidate
				go rf.BeCanidate()
				///log.Printf("Peer %d(%d) : start Candidate", rf.me,rf.currentTerm)
			}
			rf.mu.Unlock()
		}
	}
}
  1. 成为candidate后获取投票

func (rf *Raft) BeCanidate()  { 
	for {
		///log.Printf("Peer %d(%d,%d) : Being Candidate", rf.me,rf.currentTerm,rf.state)
		if rf.killed() {
			return
		}
		rf.mu.Lock()
		if rf.state != Candidate{
			rf.mu.Unlock()
			return
		}
		
		rf.currentTerm += 1
		rf.votedFor = rf.me
		rf.followerOut = 0
		voteForMe := 1
		totalVote := 1
		Term := rf.currentTerm
		rf.mu.Unlock()
		waitFlag := sync.WaitGroup{}
		///log.Printf("Peer %d(%d,%d) : start RequestVote", rf.me,rf.currentTerm,rf.state)
		for i := 0;i<len(rf.peers);i++{

			if rf.votedFor == i{
				continue
			}else{
				args := &RequestVoteArgs{
					Term : rf.currentTerm,
					CandidateId : rf.me,
					LastLogTerm : len(rf.log),
					LastLogIndex : rf.log[len(rf.log)-1].Term,
				}
				reply := &RequestVoteReply{
					Term : NILL,
					VoteGranted : false,
				}
				waitFlag.Add(1)
				go func(server int){
					///log.Printf("Peer %d(%d,%d) : RequestVote to Peer %d", rf.me,rf.currentTerm,rf.state,server)
					ok := rf.sendRequestVote(server, args, reply)
					rf.mu.Lock()
					if ok {
						if reply.VoteGranted{
							voteForMe++
						}else{
							if reply.Term > rf.currentTerm{
								rf.BeFollower(reply.Term,NILL)
								rf.mu.Unlock()
								return
							}else if reply.Term == rf.currentTerm{
								// pass
							}else if reply.Term < rf.currentTerm{
								// pass
							}
						}
					}
					totalVote++
					waitFlag.Done()
					rf.mu.Unlock()
				}(i)
				
			}

		}
		time_out := make(chan bool)
		vote_done := make(chan bool)
		vote_succ := make(chan bool)
		// 检查是否超时
		go func(){
			time.Sleep(CTimeOut * 100 *  time.Millisecond)
			time_out <- true
		}()
		// 检查是否所有requestVote都返回
		go func(){
			waitFlag.Wait()
			vote_done <- true	
			
		}()
		// 检查是否已经可以成为Leader
		go func(){
			for readtime := 0;readtime < CTimeOut;readtime++{
				time.Sleep(100 * time.Millisecond)
				if voteForMe*2 >= len(rf.peers){
				vote_succ <- true	
				}
			}
		}()

		select{
		case <- time_out:
			log.Printf("Peer %d(%d,%d) : timeout,totalVote: %d:,voteForMe:%d", rf.me,rf.currentTerm,rf.state,totalVote,voteForMe)

		case <- vote_done:
			log.Printf("Peer %d(%d,%d)%d : Vote_Done", rf.me,rf.currentTerm,rf.state,voteForMe)

		case <- vote_succ:
			log.Printf("Peer %d(%d,%d) : Vote_Success", rf.me,rf.currentTerm,rf.state)	

		}

		rf.mu.Lock()
		if rf.state == Follower || Term != rf.currentTerm{
			log.Printf("Peer %d(%d,%d) : has been follower", rf.me,rf.currentTerm,rf.state)	
			defer rf.mu.Unlock()
			return
		}
		if voteForMe*2 >= len(rf.peers){
			
			log.Printf("Peer %d(%d,%d) : BeLeader", rf.me,rf.currentTerm,rf.state)	
			go rf.BeLeader()
			rf.mu.Unlock()
			return
		}else{
			rf.mu.Unlock()

		}
		

	}
}
  1. 处理获取投票
func (rf *Raft) RequestVote(args *RequestVoteArgs, reply *RequestVoteReply) {
	// Your code here (2A, 2B).
	///log.Printf("Peer %d(%d,%d) : receive RequestVote", rf.me,rf.currentTerm,rf.state)
	rf.followerOut = 0
	rf.mu.Lock()
	defer rf.mu.Unlock()

	reply.Term = rf.currentTerm
	reply.VoteGranted = false
	// 如果收到的term<=自己的term，说明对方开始竞选前的term小于自己
	if args.Term < rf.currentTerm{
		log.Printf("Peer %d(%d,%d) : hav higher term than %d", rf.me,rf.currentTerm,rf.state,args.Term)
		return
	}else if args.Term == rf.currentTerm{
		
		if (rf.votedFor == NILL || args.CandidateId == rf.votedFor) && 
		(args.LastLogTerm>rf.log[len(rf.log)-1].Term || 
		(args.LastLogTerm==rf.log[len(rf.log)-1].Term && args.LastLogIndex>=len(rf.log)) ){
			// 如果候选者的log不比receiver新
			///log.Printf("Peer %d(%d,%d) : receive RequestVote,Be Follower", rf.me,rf.currentTerm,rf.state)
			reply.VoteGranted = true
			rf.BeFollower(args.Term, args.CandidateId)
			rf.votedFor = args.CandidateId
			return
		
		}else{
			// 如果votedfor不为NILL则说明已经进行了投票
			log.Printf("Peer %d(%d,%d) : already vote for %d", rf.me,rf.currentTerm,rf.state,rf.votedFor)
			return
		}

	}else{ //如果收到的term更大，则转换为follower
		///log.Printf("Peer %d(%d,%d) : receive RequestVote,Be Follower", rf.me,rf.currentTerm,rf.state)
		rf.votedFor = args.CandidateId
		reply.VoteGranted = true
		rf.BeFollower(args.Term, args.CandidateId)
		return
	}
}
  1. 成为Leader后维持心跳
func (rf * Raft) BeLeader(){
	rf.state = Leader
	rf.votedFor = rf.me
	rf.candidateOut = 0
	rf.followerOut = 0

	for i:=0;i<len(rf.peers);i++{
		rf.nextIndex[i] = len(rf.log)
		rf.matchIndex[i] = 0 
	}


	for {
		//log.Printf("peer:%d(%d,%d) is leader? follower", rf.me,rf.currentTerm,rf.state)
		if rf.state != Leader{
			//log.Printf("peer:%d(%d) became follower", rf.me,rf.currentTerm)
			return
		}
		for i:=0;i<len(rf.peers);i++{
			if rf.me == i{
				rf.followerOut = 0
				continue
			}
			args:=&AppendEntriesArgs{
				Term:rf.currentTerm,
				LeaderId:rf.me,
				PrevLogIndex:len(rf.log),
				PrevLogTerm:rf.log[len(rf.log)-1].Term,
				Entries:make([]Entry,2),
				LeaderCommit:len(rf.log),
			}
			reply:=&AppendEntriesReply{
				Term:0,
				Success:false,
			}
			
			go func(server int){
				//log.Printf("Peer %d(%d) : Be Leader and Sending void entry to %d", rf.me,rf.currentTerm,server)
				rf.sendAppendEntry(server, args, reply)
				return
			}(i)
		}
		time.Sleep(110*time.Millisecond)	
	}


}
  1. 处理心跳

func (rf *Raft) AppendEntry(args *AppendEntriesArgs, reply *AppendEntriesReply) {
	// Your code here (2A, 2B).
	rf.mu.Lock()
	defer rf.mu.Unlock()
	if  args.Term > rf.currentTerm{
		//log.Printf("Peer %d(%d,%d) : change to follower", rf.me,rf.currentTerm,rf.state)
		rf.BeFollower(args.Term, args.LeaderId)
		rf.followerOut = 0
		return
	}else if args.Term == rf.currentTerm{
		//log.Printf("Peer %d(%d,%d) : change to follower", rf.me,rf.currentTerm,rf.state)

		rf.followerOut = 0
		return
	}

}

还是要说这里逻辑与参数选择有诸多错误，只是作为2a的代码进行示意，真正可行的代码查看raft.go。

测试

2a的测试很简单，只有三个

TestInitialElection2A：能在指定时间选出一个Leader，并且该Leader正常发出心跳
TestReElection2A：在选出一个Leader的情况下，断掉该Leader查看是否能及时选出新的Leader，重连断掉的旧Leader，看服务集群能否重新达到共识
TestManyElections2A：在10个服务器集群里，随机断掉三个，看剩下的能否选出Leader

后两个实验都具有一定的随机性，因而一定要进行大量的测试保证代码无误

错误信息

Term x has y (>1) leaders ： Term x有了多个leader，
expected one leader, got none：没有选举出leader

eternalex
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
MIT6.824-LAB:Lab2-Lab4
03-14
MIT6.824-LAB:Lab2-Lab4
6.824-golabs-2021:MIT课程6.824（2021年Spring）实验室源代码实施
03-06
6.824-golabs-2021 实验室源代码实施。 源代码 【空白的】 文件资料
6.824-labs:我在MIT 6.824上的实现
03-09
6.824-labs:我在MIT 6.824上的实现
MIT6.824-2017-Chinese:MIT 6.824（分布式系统）的中文版
03-11
介绍 这是的个人学习笔记，引入非计算机专业出身，可能会有过多纰漏，烦请大神斧正。 6.824是用Go语言实现的一个简单的分布式系统。学习该课程可以让你对分布式系统原理有一个广泛深入的认识。 在开始学习之前，最好能拥有一定的计算机网络以及操作系统的知识。 之所以选择这一门课，我主要有以下几个考虑： 分散已经成为后台开发者的必备技能 语言自从GC问题解决后，性能非常出色，值得深入了解 那么，开始吧。 进度 Lab1：mapreduce Lab2：木筏（C部分施工中） 实验3：KV木筏 通知 该项目已不再维护，请移步重建后的版本 ，主要优化： 几个工作协程的设计更为合理 解决了所有比赛条件，修复了几率性fail的情况
MIT6.824-2018-Chinese:MIT 6.824（分布式系统）的中文版
03-11
MIT6.824-2018-中文 MIT 6.824（分布式系统）的中文版 有关详细信息，请参见 。 介绍 之前的项目（ ）由于个人原因（懒狗一条，外加毕业和工作的事）虎头蛇尾地扔在了一边。最近突然翻出来一看，觉得自己写的真的很shi。现在重开一坑，直接从lab2开始写吧。 还是先总结下之前的失败点： 竞争的种族条件没有妥善处理 代码不够优美，主循环的选择中，忙询raft状态，并在Leader的处理逻辑中sleep。 避免种族状况是非常关键的要求，因为如果没有通过go test -race测试的代码有几率导致某些测试用例失败。而这要求更好的raft结构设计。 进度 Lab1：mapreduce请移步 Lab2：木筏 实验3：KV木筏
MIT6.824-lab2A-2022篇（万字推导思路及代码构建）
幸平的博客
05-03 7183
MIT6.824-lab2A-2022篇（万字推导思路及代码构建）
6.824 Lab 2: Raft
void
08-15 930
简介 lab2主要是根据论文 In Search of an Understandable Consensus Algorithm (Extended Version) 做一个复制状态机（replicated state machine）并以此做一个有容错性的存储k/v的分布式系统。 思路 整个lab2分为ABC三个部分： lab2A主要完成leader election部分，从多个server中选举出一个leader，并让选出的leader周期性地发送心跳包给各follower； lab2B主要完成日志
6.824 lab2A
z1213035927的博客
02-10 1229
引言 恰逢寒假准备实习，便重新拾起6.824的lab，lab2主要是对Raft论文的复现，本文实现了2A部分的内容，lab2的内容难度还是很大的，写下此文便于日后复习使用。 Reference： Raft论文翻译 MIT 6.824 Lab2 翻译 Raft 算法详解（一）领导者选举 MIT 6.824 lab2 PartA 正文 2A部分将实现领导人选举和心跳包的发送，关于Raft工作原理的内容不再赘述，详见Raft论文。 一、结构体的创建和初始化 通过论文中的figure 2，便可
MIT 6.824分布式 LAB2A：Raft
MarksSa的博客
10-20 1177
Lab 2A被官方指定为中等难度，对于我这种之前很少写多线程的菜鸡而言，真的花费了大量时间，同时对于论文的理解不够深刻，导致我在写这个lab的过程中多次推倒重写其中的逻辑，以及锁使用的不熟练，让程序在执行过程中经常发生有raft节点死锁。 后续记录一下，我写这个lab 2A过程中的踩的坑。
6.824 lab2 raft实现
又菜又爱玩
08-21 404
目前感觉代码逻辑的严谨性才是最大的难点，例如发投票/发送心跳/发日志的过程，无论对于信息的接受方还是发送方，都需要通过对接受/反馈得到的信息来判断自己目前所应处的三种节点状态，这个问题在论文的Figure 2中是有提到的，另外自己参考的代码中也有对应实现，但自己复现时就没考虑周全，以至于最后对着参考代码一行一行的找问题，自己写的代码和参考代码还有很多的地方思路不太一样，就导致调bug变的异常困难。而对于persist()函数，则所有代码中，修改上述三个量的地方都应该调用一次persist()函数。
6.824 Spring 2021 -- Lab 2A
kevin的专栏
05-22 1074
实验说明：6.824 Lab 2: Raft 可视化：Raft 实现目标 根据论文Figure 2和5.2实现Raft系统的选主和心跳 整体流程​​​​​​​ 新节点启动时，大致的流程如下： 初始化自己的属性信息，主要有votedFor=-1，currentTerm=0；设置选举超时（论文的election timeout）的时间范围为1000ms-2000ms，心跳间隔为150ms；设置自己的状态为Follower，开启electionTimeout计时器。 如果接收到来自其他节点的
MIT6.824 Lab2实现与踩坑
arccosY的博客
01-19 2090
Lab2要求实现Raft协议，最主要的就是实现两个RPC方法——RequestVote和AppendEntries，每个RPC方法的参数、返回值和处理流程要完全按照论文来实现，同时要参考课程给出的Raft Structure Advice和Student Guide。下面对论文中的一些细节和go语言的实现细节做一些记录 一、Lab2A Lab2A只需要实现leader election这一个功能，测试也只有两个，但也是整个Lab2，3，4的开始，所以并不简单 currentTerm和votedFor的改变：
Mit6.824-lab2d-2022
qq_41703198的博客
09-30 752
Mit6.824-lab2d-2022实验思路与代码，以及整个lab2总结
6.824 Lab2思路及实现
weixin_39484674的博客
05-22 407
6.824 分布式课程
MIT 6.824分布式 LAB2D：Raft
MarksSa的博客
11-24 1773
Lab 2D是lab2的最后阶段了，这一阶段就是加了一个快照机制，但是这种实验中这个快照是何时以及如何进行的，建议大家事前先去看一看，不然就会碰到各种问题。例如，我在测试过程中莫名其妙发现leader死锁了，以及测试显示lastapplied的index值和commandIndex值不匹配等问题。
「实验记录」MIT 6.824 Raft Lab2A Leader Election
士全的CSDN，用心连载，欢迎关注
05-14 825
MIT 6.824 Raft Lab2A Leader Election
MIT-6.824 Raft lab2A
diyxuan的博客
08-14 364
MIT-6.824 Raft lab2A部分的实验过程
MIT6.824 Lab2-Raft(A&B&C&D)
a2269713951的博客
08-13 260
然后就是什么时候进行日志复制，查了一下大部分都是在start函数中每接收到一个日志就发起一个复制请求，这样会导致多个请求之间的appendEntries是重复包含的，比如当第一条日志还没复制完成时，后续节点又接收到了多条日志，这样就会发起多轮请求，但是此时前面的请求还没复制完成，则后面的请求appendEntries中必然是包含前面的重复日志，这样效率实属低下而且不优雅。这个实验基本是按照论文的描述进行实现的，在实验的过程中能很好地掌握和理解raft的各种细节，加深对于raft的理解。
[MIT6.824] Spring2021 Lab 2: Raft
最新发布
AntiO2的博客
09-22 512
总体来说，只看lecture对raft还是有些认知不到位的，就像我说我的疑问那里，还有很多不清晰的地方。但是一旦上手做了代码，就把细节的部分掰开弄清楚了。加上网上好心人写的博客很多，知乎也有各种细节问题的讨论，最终还是顺利完成了。最后就是一起测试了。这里的超时选举时间都是300∼900ms300∼900ms图一是每50ms发送一次心跳，图2是每100ms发送一次心跳。可以看到第一次的总时间较短，但CPU用时高。心跳间隔长的总时间较长，但CPU用短（因为等待时间多）。
mit6.824-MapReduce的Lab1的实现
05-22
MIT 6.824 课程的 Lab1 是关于 Map 的实现，这里单介绍一下实现过程。 MapReduce 是一种布式计算模型，它可以用来处理大规模数据集。MapReduce 的核心想是将数据划分为多个块，每个块都可以在不同的节点上并行处理，然后将结果合并在一起。 在 Lab1 中，我们需要实现 MapReduce 的基本功能，包括 Map 函数、Reduce 函数、分区函数、排序函数以及对作业的整体控制等。 首先，我们需要实现 Map 函数。Map 函数会读取输入文件，并将其解析成一系列键值对。对于每个键值对，Map 函数会将其传递给用户定义的 Map 函数，生成一些新的键值对。这些新的键值对会被分派到不同的 Reduce 任务中，进行进一步的处理。 接着，我们需要实现 Reduce 函数。Reduce 函数接收到所有具有相同键的键值对，并将它们合并成一个结果。Reduce 函数将结果写入输出文件。 然后，我们需要实现分区函数和排序函数。分区函数将 Map 函数生成的键值对映射到不同的 Reduce 任务中。排序函数将键值对按键进行排序，确保同一键的所有值都被传递给同一个 Reduce 任务。 最后，我们需要实现整个作业的控制逻辑。这包括读取输入文件、调用 Map 函数、分区、排序、调用 Reduce 函数以及写入输出文件。 Lab1 的实现可以使用 Go 语言、Python 或者其他编程语言。我们可以使用本地文件系统或者分布式文件系统（比如 HDFS）来存储输入和输出文件。 总体来说，Lab1 是一个比较简单的 MapReduce 实现，但它奠定了 MapReduce 的基础，为后续的 Lab 提供了良好的基础。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值