操作系统实验二：银行家算法

最新推荐文章于 2024-07-19 13:59:11 发布
最新推荐文章于 2024-07-19 13:59:11 发布
阅读量439 收藏 1
点赞数
分类专栏： 操作系统 文章标签： 算法 c++ 数据结构 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu97_/article/details/125359413
版权

操作系统实验二：银行家算法

银行家算法目录

一、实验目的

  1. 了解死锁避免的原理。
  2. 研究银行家算法的实现方法。

二、实验要求及内容

  1. 编程实现银行家算法，加深了解有关资源申请、避免死锁等概念，并体会和了解死锁的避免死锁的具体实施方案。
  2. 列出调试通过程序的清单，并附上文档说明。
  3. 总结上机调试过程中遇到的问题和解决方法及感想。

三、实验代码

// 银行家算法.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
#include <iostream>
#include<vector>
#include<algorithm>
#include <iomanip>
 
using namespace std;
int num_Process = 0;
int num_Source = 0;
vector<int>TotalSource;
vector<int>Available ;
vector<int>Request;
vector<char> nameSource;
vector<int>SucceesName;
vector<int> work;
vector<int> workallocation;
 
class BankObject
{
private:
	char name;
	vector<int> max;
	vector<int> allocation;
	vector<int> need;
	bool finish;
public:
	BankObject(char pname,vector<int>pmax, vector<int>pallocation,vector<int>pneed) :
		name(pname),max(pmax), allocation (pallocation),need(pneed)
	{
		finish = 0;
	}
	operator vector<int>() const
	{
		return need;
	}
	vector<int>& Max()
	{
		return max;
	}
	const vector<int>& Max()const 
	{
		return max;
	}
	char& Name()
	{
		return name;
	}
	const char& Name()const
	{
		return name;
	}
	vector<int>& Allocation()
	{
		return allocation;
	}
	const vector<int>& Allocation()const
	{
		return allocation;
	}
	vector<int>& Need()
	{
		return need;
	}
	const vector<int>& Need()const
	{
		return need;
	}
	bool & Finish()
	{
		return finish;
	}
	const  bool & Finish()const
	{
		return finish;
	}
};
class Manage
{
private:
	vector<BankObject> ProList;
public:
	//初始化各个进程的Max，Allocation，Need向量
	void Add(BankObject process)
	{
		ProList.push_back(process);
	}
 
	void SetWorkAvailable()
	{
		for (int i = 0; i < num_Source; i++)
		{
			for (int j = 0; j < num_Process; j++)
			{
				Available[i] = Available[i] - ProList[j].Allocation()[i];
			}
		}		
		work = Available;
	}
	
	void CalTotolSource()
	{
		TotalSource = Available;
		for (int i = 0; i < num_Source; i++)
		{
			for (int j = 0; j < num_Process; j++)
			{
				TotalSource.push_back( TotalSource[i] + ProList[j].Allocation()[i]);
			}
		}
	}
	void CalMax()
	{
		for (int i = 0; i < num_Process; i++)
		{
			for (int j = 0; j < num_Source; j++)
			{
				ProList[i].Max()[j] = ProList[i].Allocation()[j] + ProList[i].Need()[j];
			}
		}
	}
	void CalNeed()
	{
		for (int i = 0; i < num_Process; i++)
		{
			for (int j = 0; j < num_Source; j++)
			{
				ProList[i].Need()[j] = ProList[i].Max()[j] - ProList[i].Allocation()[j];
			}
		}
	}
	void CalAllocation()
	{
		for (int i = 0; i < num_Process; i++)
		{
			for (int j = 0; j < num_Source; j++)
			{
				ProList[i].Allocation()[j] = ProList[i].Max()[j] - ProList[i].Need()[j];
			}
		}
	}
	bool Compare(BankObject obj1, vector<int>work)
	{
		bool success = true;
		for (int i = 0; i < num_Source; i++)
		{
			if (obj1.Need()[i] > work[i])//安全性算法Step1：比较不成功
			{
				success = false;
			}
		}
		return success;
	}
 
	bool SafeCheak()
	{
		cout << "资源  " << setw(2) << "Work" << setw(8) << "Need" << setw(13) << "Allocation" << setw(17) << "Work+Allocation" << setw(8) << "Finish" << endl;
		cout << "进程" << setw(4);
		for (int j = 0; j < 4; j++)
		{
			cout << setw(3);
			if (j == 2)
			{
				cout << setw(4);
			}
			if (j == 3)
			{
				cout << setw(8);
			}
			for (int i = 0; i < num_Source; i++)
			{
				cout << nameSource[i] << " ";
			}
		}
		cout << endl;
		bool success = 0;
		int tag = 0;
		//Step1：设置两个工作向量（已完成）
		//Step2：从进程集合中找满足条件的进程
		for (int k = 0, count = 0; k < num_Process; k++)
		{
			for (int i = 0; i < num_Process; i++)
			{
				if (ProList[i].Finish() == 0 && Compare(ProList[i], work))
				{
					//打印通过安全检查进程的Work，Need，Allocation
					SucceesName.push_back(i);
					cout << "P" << i << setw(4) << "|";
					for (int j = 0; j < num_Source; j++)
					{
						cout << work[j];
						if (j + 1 == num_Source)
						{
							cout << "|";
							break;
						}
						cout << " ";
					}
					cout << setw(2) << "|";
					for (int j = 0; j < num_Source; j++)
					{
						cout << ProList[i].Need()[j];
						if (j + 1 == num_Source)
						{
							cout << "|";
							break;
						}
						cout << " ";
					}
 
					ProList[i].Finish() = 1;
 
					//打印Work+Allocation矩阵，
					cout << setw(3) << "|";
					for (int j = 0; j < num_Source; j++)
					{
						cout << ProList[i].Allocation()[j];
						if (j + 1 == num_Source)
						{
							cout << "|";
							break;
						}
						cout << " ";
					}
					for (int j = 0; j < num_Source; j++)
					{
						work[j] = work[j] + ProList[i].Allocation()[j];
					}
					cout << setw(7) << "|";
					for (int j = 0; j < num_Source; j++)
					{
						cout << work[j];
						if (j + 1 == num_Source)
						{
							cout << "|";
							break;
						}
						cout << " ";
					}
					cout << setw(10) << "|" << ProList[i].Finish() << "|" << endl;
					count++;//找到一个安全序列
					if (count == num_Process)//找到所有的安全序列
					{
 
						success = 1;
						//打印安全序列
						cout << "------------***^*^***-------------" << endl;
						cout << "系统处于安全状态，可以找到一个安全序列{";
						for (int j = 0; j < num_Process; j++)
						{
							cout << "P";
							cout << SucceesName[j] << "，";
						}
						cout << "}" << endl;
						cout << "------------***^*^***-------------" << endl;
						goto end;
					}
				}
			}
		}
		if (success == 0)//没有找到安全序列
		{
			cout << "------------***^*^***-------------" << endl;
			cout << "该系统未处于安全状态！" << endl;
			cout << "------------***^*^***-------------" << endl;
		}
		
	end:
		for (int i = 0; i < num_Process; i++)
		{
			ProList[i].Finish() = 0;
		}
		return success;
	}
	//processi是要请求的进程序列
	void BankAlgorithm(int processi)
	{
		//Step1：
		bool success = 1;
		for (int j = 0; j < num_Source; j++)
		{
			if (Request[j] > ProList[processi].Need()[j])
			{
				success = 0;
				cout << "该进程所申请的资源数量已经超过他所宣布的最大值！" << endl;
			}
		}
		//其余步骤都是在step1执行成功的条件下执行的
		//Step2：
		if (success)
		{
			for (int j = 0; j < num_Source; j++)
			{
				if (Request[j] > Available[j])
				{
					success = 0;
					cout << "系统尚无足够资源！P"<<processi<<"进程须等待！" << endl;
				}
			}
		}
		//Step3：系统试分配
		if (success)
		{
			for (int j = 0; j < num_Source; j++)
			{
				Available[j] = Available[j] - Request[j];
				ProList[processi].Allocation()[j] = ProList[processi].Allocation()[j] + Request[j];
				ProList[processi].Need()[j] = ProList[processi].Need()[j] - Request[j];
			}
			work = Available;
			success = SafeCheak();
			if (success == 0)//安全性检查未通过
			{
				//回收刚才试分配的资源
				for (int j = 0; j < num_Source; j++)
				{
					Available[j] = Available[j] + Request[j];
					ProList[processi].Allocation()[j] = ProList[processi].Allocation()[j] - Request[j];
					ProList[processi].Need()[j] = ProList[processi].Need()[j] + Request[j];
				}
				work = Available;
			}
		}
	}
	void Print_T0()
	{
		cout << "资源  " << setw(3) << "Max" << setw(13) << "Allocation" << setw(6) << "Need" << setw(11) << "Available" << endl;
		cout << "进程" << setw(4);
		for (int j = 0; j < 4; j++)
		{
			cout << setw(3);
			if (j == 2)
			{
				cout << setw(4);
			}
			if (j == 3)
			{
				cout << setw(5);
			}
			for (int i = 0; i < num_Source; i++)
			{
				cout << nameSource[i] << " ";
			}
		}
 
		cout << endl;
		for (int i = 0; i < num_Process; i++)
		{
 
			cout << "P" << i << setw(4) << "|";
			for (int j = 0; j < num_Source; j++)
			{
				cout << ProList[i].Max()[j];
				if (j + 1 == num_Source)
				{
					cout << "|";
					break;
				}
				cout << " ";
			}
			cout << setw(2) << "|";
			for (int j = 0; j < num_Source; j++)
			{
				cout << ProList[i].Allocation()[j];
				if (j + 1 == num_Source)
				{
					cout << "|";
					break;
				}
				cout << " ";
			}
			cout << setw(3) << "|";
			for (int j = 0; j < num_Source; j++)
			{
				cout << ProList[i].Need()[j];
				if (j + 1 == num_Source)
				{
					cout << "|";
					break;
				}
				cout << " ";
			}
			if (0 == i)
			{
				cout << setw(3) << "|";
				for (int j = 0; j < num_Source; j++)
				{
					cout << Available[j] << setw(2);
				}
				cout << "|";
			}
			cout << endl;
		}
	}
	
	void Menu()
	{
		cout << "**********^^^*^^^********" << endl;
		cout << "1.显示当前资源情况" << endl;
		cout << "2.安全性检查" << endl;
		cout << "3.请求资源" << endl;
		cout << "4.退出本系统" << endl;
		cout << "**********^^^*^^^********" << endl;
	}
	void InitMenu()
	{
		cout << "1.输入Max，allocation，totalsource" << endl;
		cout << "2.输入allocation，need，available" << endl;
		cout << "3.输入Max，Need，available" << endl;
	}
};
void CharName()
{
	for (int i = 0; i < num_Source; i++)
	{
		nameSource.push_back(i + 65);
	}
}
 
int main()
{
	Manage process;
	bool success;
	int choose = 0;
	int processi = 0;
	char end = 'y';
	vector<int> num_Max;
	vector<int> num_Allocation;
	vector<int> num_Need;
	int requestsourcenum = 0;
	cout<<"现在开始进行初始化："<<endl;
	cout << "请输入进程的数量：";
	cin >> num_Process;
	cout << "请输入资源的数量：";
	cin >> num_Source;
	CharName();
	int valueAvailable = 0;
	int valueMax = 0, valueAllocation = 0, valueNeed = 0;
	int init = 0;
	process.InitMenu();
	way:
	cout << "请选择初始化方式：";
	cin >> init;
	if (1 == init)
	{
		for (int i = 0; i < num_Source; i++)
		{
			cout << "请输入资源" << nameSource[i] << "的总量：";
			cin >> valueAvailable;
			TotalSource.push_back(valueAvailable);
		}
		for (int i = 0; i < num_Process; i++)
		{
			cout << "请输入进程P" << i << "的Max：";
			for (int j = 0; j < num_Source; j++)
			{
				cin >> valueMax;
				num_Max.push_back(valueMax);
			}
			cout << "请输入进程P" << i << "的Allocation：";
			for (int j = 0; j < num_Source; j++)
			{
				cin >> valueAllocation;
				num_Allocation.push_back(valueAllocation);
				num_Need.push_back(0);
			}
			BankObject obj1(i, num_Max, num_Allocation,num_Need);
			process.Add(obj1);
			num_Max.clear();
			num_Allocation.clear();
			num_Need.clear();
		}		
		Available = TotalSource;
		process.CalNeed();
		process.SetWorkAvailable();
	}
	else if(2==init)
	{
		for (int i = 0; i < num_Process; i++)
		{
			
			cout << "请输入进程P" << i << "的Allocation：";
			for (int j = 0; j < num_Source; j++)
			{
				cin >> valueAllocation;
				num_Allocation.push_back(valueAllocation);
			}
			cout << "请输入进程P" << i << "的Need：";
			for (int j = 0; j < num_Source; j++)
			{
				cin >> valueNeed;
				num_Need.push_back(valueNeed);
				num_Max.push_back(0);
			}
			BankObject obj1(i, num_Max, num_Allocation,num_Need);
			process.Add(obj1);
			num_Max.clear();
			num_Allocation.clear();
			num_Need.clear();
		}
		for (int i = 0; i < num_Source; i++)
		{
			cout << "请输入资源" << nameSource[i] << "的available：";
			cin >> valueAvailable;
			Available.push_back(valueAvailable);
		}
		//计算各资源的总数
		process.CalTotolSource();
		process.CalMax();
		work = Available;
	}
	else if (3 == init)
	{
		for (int i = 0; i < num_Process; i++)
		{
 
			cout << "请输入进程P" << i << "的Max：";
			for (int j = 0; j < num_Source; j++)
			{
				cin >> valueMax;
				num_Max.push_back(valueMax);
			}
			cout << "请输入进程P" << i << "的Need：";
			for (int j = 0; j < num_Source; j++)
			{
				cin >> valueNeed;
				num_Need.push_back(valueNeed);
				num_Allocation.push_back(0);
			}
			BankObject obj1(i, num_Max, num_Allocation, num_Need);
			process.Add(obj1);
			num_Max.clear();
			num_Allocation.clear();
			num_Need.clear();
		}
		for (int i = 0; i < num_Source; i++)
		{
			cout << "请输入资源" << nameSource[i] << "的available：";
			cin >> valueAvailable;
			Available.push_back(valueAvailable);
		}
		//计算各资源的总数
		process.CalTotolSource();
		process.CalAllocation();
		work = Available;
	}
	else
	{
		cout << "请重新输入初始化方式！" << endl;
		goto way;
	}
	while (1)
	{
		process.Menu();
		cout << "请输入你的选择：";
		cin >> choose;
		if (choose < 0 || choose>4)
		{
			cout << "请重新输入你的选择！" << endl;
		}
		switch (choose)
		{
		case 1:
			process.Print_T0();
			break;
		case 2:
			process.SafeCheak();
			break;
		case 3:
			cout << "进程列表：" << endl;
			for (int i = 0; i < num_Process; i++)
			{
				cout << "P" << i << "-->" << i << endl;
			}
 
		process:
			cout << "请输入要申请资源的进程：";
			cin >> processi;
			if (processi<0 || processi>num_Process)
			{
				cout << "对不起，请重新输入进程！！！" << endl;
				goto process;
			}
 
			cout << "请输入要申请的各种资源数量：";
			for (int i = 0; i < num_Source; i++)
			{
				cin >> requestsourcenum;
				Request.push_back(requestsourcenum);
			}
 
			process.BankAlgorithm(processi);
			Request.clear();
			break;
		case 4:
			return 0;
			break;
		}
	}
 
}

四、实验结果截图

1.初始化
在这里插入图片描述

2、 显示当前资源情况：
在这里插入图片描述
3、 安全性检查：
在这里插入图片描述
4、 P1请求资源
在这里插入图片描述
5、 P4请求资源：
在这里插入图片描述
6、 P3请求资源：
在这里插入图片描述

五、实验总结

通过此次实验，我对银行家算法的理解更加深入，了解死锁避免的基本思想是动态地检测资源分配状态，以确保循环等待条件不成立，从而确保系统处于安全状态。认识到所谓安全状态是指：如果系统能按某个顺序为每个进程分配资源（不超过其最大值），那么系统状态是安全的，换句话说就是，如果存在一个安全序列，那么系统处于安全状态。
在这次实验过程中我遇到了代码运行不出来的情况，为此我十分焦虑，不过在不断查阅资料的和翻看书本的情况下我用c++实现了银行家算法；这次实验让我了解和如何避免死锁，系统对进程发出的每一个系统能够满足的资源申请进行动态检查，并根据检查结果决定是否分配资源；如果分配后系统可能发生死锁，则不予分配，否则予以分配。这是一种保证系统不进入死锁状态的动态策略。总之，我学到了很多。

牛肉L
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于银行家算法的问题
weixin_43331200的博客
11-06 1691
关于银行家算法的问题 在校大学生,刚学习操作系统,在github上面参考了银行家算法的代码,有两个问题不是很了解,问题的出现都是在进程的安全性判断上. 问题: 1.为什么要在申请一个进程的时候做一遍安全性检查?不能进程申请完了再做安全性检查吗?安全性不是相对于整个进程序列来说的吗?? 2.在ifInSafeMode()中为什么要对i赋值为-1呢? 代码如下: /**********...
操作系统学习笔记（七）---银行家算法小结
雲的博客
01-19 6815
银行家算法： Allocation（已分配资源） Request（还需要的资源） Availiable（当前可用资源） Max（每个进程的最大需求） work（？） finish（进程i是否完成）（注意进程完成后会释放资源） 细分为2个算法：即安全性算法和资源请求算法 安全性算法：确定系统状态是否安全（是否有一个进程处理顺序满足所有进程的资源分配） 资源请求算法：如果进程P向系统...
操作系统实验之银行家算法
01-08
操作系统实验之银行家算法，里面已经包含报告，报告只需要写个人感想即可
银行家算法
weixin_43233174的博客
03-30 1303
实验一 银行家算法 一、 实验题目 银行家算法 二、 实验内容 必须实现多资源的管理机制。（至少是三类资源的管理，需要有良好的输入界面和交互性） 三、 实验过程 1、实验原理 银行家算法名字源于该算法实际上是用于确保银行系统不会用尽系统资源，因为当银行系统不再满足所有客户的需求，系统将不会分配钱（看作资源）给客户，银行必须确保对钱的请求不会导致银行系统处于不安全状态。如果上述情况不会发生，则该情...
操作系统银行家算法实验报告
m0_59834108的博客
06-30 1379
操作系统银行家算法实验报告 操作系统实验报告（二）银行家算法_mp-ui的博客-CSDN博客_银行家算法实验报告【实验报告】操作系统，银行家算法，_霜前月下的博客-CSDN博客_银行家算法实验报告 操作系统——银行家算法（Banker's Algorithm） - 王陸 - 博客园 (cnblogs.com) 计算机操作系统_银行家算法_魏宇轩的博客-CSDN博客_银行家算法...
计算机操作系统实验二：银行家算法实验报告材料书.doc
10-14
计算机操作系统实验二：银行家算法实验报告材料书 本实验报告的主要目的是通过使用银行家算法实现系统资源的分配和安全性检查模拟，提高学生对操作系统资源分配功能的深刻理解，并培养学生对操作系统开发的兴趣与...
操作系统实验二银行家算法
06-17
在本实验中，银行家算法被用来有效地分配三种类型的资源：A、B和C，它们的数量分别为10、15和12。系统中有5个并发执行的进程，这些进程通过进程控制块（PCB）进行管理，其中包含了进程名、需要的资源总数、已分配的...
操作系统实验二——银行家算法
08-29
操作系统中的死锁问题是一个...通过这个实验，学生可以深入理解银行家算法的工作原理，掌握如何预防死锁，并在实践中应用C语言编程技巧。这样的练习有助于提升对操作系统中资源管理的理解，以及解决实际问题的能力。
操作系统实验银行家算法
06-25
死锁会引起计算机工作僵死，因此操作系统中必须防止。本实验的目的在于让学生独立的使用高级语言编写和调试一个系统动态分配资源的简单模拟程序，了解死锁产生的条件和原因，并采用银行家算法有效地防止死锁的发生，以加深对课堂上所讲授的知识的理解。 设计有n个进程共享m个系统资源的系统，进程可动态的申请和释放资源，系统按各进程的申请动态的分配资源。 系统能显示各个进程申请和释放资源，以及系统动态分配资源的过程，便于用户观察和分析；
银行家算法 实验报告
07-25
实验目的和要求 目的 1、 理解银行家算法。 2、 掌握进程安全性检查的方法与资源分配的方法。 要求 1、 模拟一个银行家算法； 2、 初始化时让系统拥有一定的资源； 3、 用键盘输入的方式申请资源； 4、 如果预分配后，系统处于安全状态，则修改系统的资源分配情况； 5、如果预分配后，系统处于不安全状态，则提示不能满足请求，
操作系统银行家算法设计报告
12-31
本资源是完整的操作系统课程设计报告，主要包含银行家算法的流程图及算法的实现代码
银行家算法 源码+实验报告（用了自取）
嘴大且吃雯的博客
01-02 4767
银行家算法400行代码，用自取，逻辑清晰、思路完整、代码布局合理，复制粘贴即可使用
银行家算法的分析与实现
木子皿--啥都不会的菜鸟
04-15 1315
文章目录1 银行家算法的分析与实现 1 银行家算法的分析与实现 问题描述： 研究一个银行家如何将总数一定的资金，安全的借给若干个顾客，使顾客既能满足对资金的需求，也使银行家可以收回自己的全部资金，不至于破产。 一些限制条件： 每个顾客在借款前必须提前说明所需资金总额。 每次借钱都是以一个单位进行（如：一个单位为1万人民币）。 顾客在拿到一个单位的借款前可能需要等待。 银行保证顾客的等待时间是...
银行家的算法实现—全部安全序列求解dfs以及错误分析
ZQYnn's blog
12-21 2647
银行家算法 文章目录银行家算法银行家算法的概述银行家算法代码测试样例代码思路 错误分析运行结果 银行家算法的概述 银行家算法是一种避免死锁，为不同进程分配资源的，保证不同进程都能分配到资源，最终求出实现资源分配后不同进程运行的序列，此序列称为安全序列， 具体的原理和解释就看书吧~ 我这里将书中的例子写成代码，时间关系目前先不详解啦，在这里给出的代码实现的过程。 银行家算法代码 #include &...
关于银行家算法的讨论
slb18220570825的博客
05-13 2263
import java.util.Scanner; public class Banker { int[] Available = {10, 8, 7}; //资源数 int[][] Max = new int[3][3]; //最大需求 int[][] Alloction = new int[3][3]; //分配 int[][] Need = new ...
操作系统实验之“银行家算法”
lier的博客
12-16 3214
一、前言 银行家算法主要用于判断内存分配是否安全合理。 1、是否合理 主要是看进程的请求是否小于所需值，以及是否小于现有资源量。这个部分比较简单，根据available,need这两个二维矩阵就可以直接判断。 2、是否安全 主要根据安全性检查算法，主要思路是，对于分配后的available,allocation,need三大矩阵，是否能找到一种顺序能使得所有进程都能运行完。步骤如下： （一般描述中...
操作系统-银行家算法上机实验
cangzhexingxing的博客
05-19 3946
操作系统原理实验报告 实验题目 实验三银行家算法 实验三、银行家算法 1.1 实验目的 多个进程动态地共享系统的资源可能会产生死锁现象。死锁的产生，必须同时满足四个条件，第一个是互斥条件，即一个资源每次只能由一个进程占用；第二个为请求和保持条件，即一个进程请求资源不能满足时，它必须等待，但它仍继续保持已得到的所有其它资源；第三个是不剥夺条件，任何一个进程不能抢占另一个进程已经获得且未释放的资源；第四个为循环等待条件，系统中存在若干个循环等待的进程，即其中每一个进程分别等待它前一...
【18】输出字符菱形
最新发布
2301_78786609的博客
07-19 288
用‘*’构造一个对角线长n个字符，倾斜放置的菱形。
操作系统实验报告：银行家算法与进程同步
"这份文档是关于南京邮电大学管理学院《操作系统》课程的一次和第二次实验报告模板，涵盖了进程管理、同步问题、银行家算法、读者-写者问题、以及虚拟存储器管理的实验内容。实验旨在让学生理解和掌握操作系统核心...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值