进程调度实习

最新推荐文章于 2024-11-12 21:59:57 发布
最新推荐文章于 2024-11-12 21:59:57 发布
阅读量154 收藏
点赞数
分类专栏： C 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45691787/article/details/106796019
版权 
#include<stdio.h>
#include<string.h>
#include<stdlib.h>


/*******以下为先来先服务主要算法*****************/
//


//声明一个先来先服务的结构，成员包含进程运行的各种时间
struct fcfs{
char name[20];//进程名字
float ddtime; //到达时间
float yxtime; //运行时间
float kstime; //开始时间
float wctime; //完成时间
float zztime; //周转时间
float dqzztime; //带权周转时间
};

struct fcfs a[1000]; //定义结构数组，一个数组元素中记录有结构中各种信息


void intput1(fcfs *p,int n)  //输入进程信息的函数
{
int i;
  for(i=0;i<n;i++)  //输入必要的几个信息
  {
	  printf("\n****************************\n",i+1);
			printf("请您输入第%d个进程的下列信息:",i+1);

			printf("\n\n进程名字:");
			scanf("%s",&p[i].name);

			printf("到达时间:");
			scanf("%f",&p[i].ddtime);

			printf("运行时间:");
			scanf("%f",&p[i].yxtime);
  }
   printf("\n****************************\n",i+1);
}



void sort(fcfs *p,int n)   //进程根据“到达时间”进行排序
{
	int i,j;
for(i=0;i<n;i++)
  for(j=i+1;j<n;j++)
	  if(p[i].ddtime>p[j].ddtime)  //如果i的到达时间小于j的到达时间，就交换
	  {
		  fcfs temp; //定义结构类型的变量，交换时进程内的各种信息都被交换
		  temp=p[i];
		  p[i]=p[j];
		  p[j]=temp;
	  }

	  printf("\n进程执行顺序为: ");
	    for(i=0;i<n;i++)
		   printf("%s  ",p[i].name);
}


void output1(fcfs *p,int n)//定义输入函数，输入进程的各种信息
{
	int k;
	printf("\n\n进程的相关信息如下表所示:");
    printf("\n------------------------------------------------------------------------------------------------------------");
	printf("\n进程名字\t到达时间\t运行时间\t开始时间\t完成时间\t周转时间\t带权周转时间\n");
	printf("------------------------------------------------------------------------------------------------------------");


	for(k=0;k<n;k++)
	{
	 printf("\n%s\t\t%.2f\t\t%.2f\t\t%.2f\t\t%.2f\t\t%.2f\t\t%.2f\n",p[k].name,p[k].ddtime,p[k].yxtime,p[k].kstime,p[k].wctime,p[k].zztime,p[k].dqzztime);
	 printf("------------------------------------------------------------------------------------------------------------");
	}
	printf("\n");
}


void FCFS(fcfs *p,int n)  //运行函数计算进程的各种时间
{
  int k;
  for(k=0;k<n;k++)  //计算开始时间和完成时间
  {
	  if(k==0)  //k=0，表示第一个进程到达
	  {
		  p[k].kstime=p[k].ddtime;     //第一个进程的开始时间就是它的到达时间
		  p[k].wctime=p[k].ddtime+p[k].yxtime;  //完成时间=到达时间+运行时间
	  }
	   else
	   {
		   if(p[k].ddtime<=p[k-1].wctime)  //如果这个进程的到达时间小于上一个进程的完成时间
			   p[k].kstime=p[k-1].wctime;  //此进程的开始时间=上一个进程的完成时间
		   else
			   p[k].kstime=p[k].ddtime;
		   p[k].wctime=p[k].kstime+p[k].yxtime;   //此进程的完成时间=此进程的开始时间+运行时间
	   }

	       p[k].zztime=p[k].wctime-p[k].ddtime;  //周转时间=完成时间-到达时间
	       p[k].dqzztime=p[k].zztime/p[k].yxtime;  //带权周转时间=周转时间/运行时间
  }
}






/*******以下为时间片轮转算法*****************/
//


struct shijian //声明一个时间结构，包含了各种所用到的时间
{ 
char name[20];//进程名字
float ddtime;//到达时间
float yxtime;//运行时间
float sytime;//剩余时间
float wctime;//完成时间
float kstime;//开始时间
float zztime;//周转时间
float dqzztime;//带权周转时间
int number;//记录进程执行次数
int sign;   //进程完成的标志（1表示完成，0表示还没有完成）
};

struct shijian time[1000];

void intput2(shijian *p,int n)  //输入进程信息的函数
{
int i;
  for(i=0;i<n;i++)  //输入必要的几个信息
  {
	  printf("\n****************************\n",i+1);
			printf("请您输入第%d个进程的下列信息:",i+1);

			printf("\n\n进程名字:");
			scanf("%s",&p[i].name);

			printf("到达时间:");
			scanf("%f",&p[i].ddtime);

			printf("运行时间:");
			scanf("%f",&p[i].yxtime);

			p[i].sytime=p[i].yxtime;
			p[i].sign=0;
  }
    printf("\n****************************\n",i+1);
}


void sort2(shijian *p,int n)   //进程根据“到达时间”由先到后进行排序
{
	int i,j;
for(i=0;i<n;i++)
  for(j=i+1;j<n;j++)
	  if(p[i].ddtime>p[j].ddtime)  //如果i的到达时间小于j的到达时间，就交换
	  {
		  shijian temp; //定义结构类型的变量，交换时进程内的各种信息都被交换
		  temp=p[i];
		  p[i]=p[j];
		  p[j]=temp;
	  }

	  printf("\n进程按照到达时间排序:");
	  for(i=0;i<n;i++)
		  printf("%s  ",p[i].name);
}


void output2(shijian *p,int n)//定义输入函数，输入进程的各种信息
{
	int i;
	printf("\n\n进程的相关信息如下表所示:");
	printf("\n------------------------------------------------------------------------------------------------------------------------\n");
	printf("进程名字\t到达时间\t开始时间\t运行时间\t完成时间\t周转时间\t带权周转时间\t执行次数\n");
    printf("------------------------------------------------------------------------------------------------------------------------\n");

	for(i=0;i<n;i++)
	{
	 printf("%s\t\t%.2f\t\t%.2f\t\t%.2f\t\t%.2f\t\t%.2f\t\t%.2f\t\t%d\n",p[i].name,p[i].ddtime,p[i].kstime,p[i].yxtime,p[i].wctime,p[i].zztime,p[i].dqzztime,p[i].number);
	 printf("------------------------------------------------------------------------------------------------------------------------\n");
	}
	printf("\n");
}



void compare(shijian *p,int t,int n,float *nowtime,int *flag,int *sum)//比较进程与时间片关系的函数
{
	int i;
    for(i=0;i<n;i++)
		{
			if(p[i].sign==1)  //如果此进程已经完成
				continue;
			else              //如果此进程没有完成
			{
				
				if(*nowtime>=p[i].ddtime)
				{
				     	*flag=1;  //就绪队列中有进程
				     	if(p[i].sytime<=t) //如果此进程剩余服务时间小于一个时间片
						{
				     	    p[i].number++;  //执行次数加一

							if(p[i].number==1){p[i].kstime=*nowtime;}//开始时间为当前的时间
				        	*nowtime=*nowtime+p[i].sytime;
							p[i].wctime=*nowtime;

							p[i].zztime=p[i].wctime-p[i].ddtime;  //周转时间=完成时间-到达时间
	                        p[i].dqzztime=p[i].zztime/p[i].yxtime;  //带权周转时间=周转时间/运行时间
					        p[i].sign=1; //标志着这个进程做完了
				        	*sum=*sum+1; //完成的进程数加一
					        p[i].sytime=0;//剩余时间为0
						}

			            else               //如果此进程剩余服务时间大于一个时间片
						{
							*flag=1;  //就绪队列中有进程
						    p[i].number++;  //执行次数加一

                            if(p[i].number==1){p[i].kstime=*nowtime;}//开始时间为当前的时间

				 		    p[i].sytime=p[i].sytime-t;
							*nowtime=*nowtime+t;
						}
				}

			}
		}
}


void RR(shijian *p,int n) //时间片函数
{
	int t,i;  //t表示时间片
	int SUM=0; //记录完成进程数目
	int FLAG=0; //进程是否进入就绪队列的标志（1表示进入了，0表示没有进入）
	float NOW=0; //记录当前时间

	NOW=p[0].ddtime; //记录当前时间的初值是多少
	p[0].kstime=p[0].ddtime;  //第一个到达的进程开始时间与到达时间相等

	printf("\n\n请您输入时间片：");
	scanf("%d",&t);

	for(i=0;i<n;i++){p[i].number=0;} //初始化进程的执行次数为0；

	while(SUM<n)
	{
		FLAG=0; //设就绪队列中没有进程

	   compare(p,t,n,&NOW,&FLAG,&SUM);

	   if(FLAG==0&&SUM<n)  //如果进程没有执行完，但是就绪队列中已经没有进程了（说明前面进程都执行完，下一个进程还不到）
	   {
		   for(i=0;i<n;i++)
		   if(p[i].sign==0){NOW=p[i].ddtime;break;}
	   }
	}
}


/*******以下为优先级调度算法*****************/
//

struct priority//声明一个结构，包含了各种所用到的时间
{ 
char name[30];//进程名字
float yxtime;//运行时间
float kstime;//开始时间
float sytime;//剩余时间
float ddtime;//到达时间
float wctime;//完成时间
float zztime;//周转时间
float dqzztime;//带权周转时间
int youxian;//优先数
int sign;  //进程完成的标志（1表示完成，0表示还没有完成）
};

struct priority pr[50];

void intput3(priority *p,int n)//定义输入函数，输入进程的各种信息
{
	int i;
		for(i=0;i<n;i++)
		{
			printf("\n****************************\n",i+1);
			printf("请您输入第%d个进程的下列信息:",i+1);

			printf("\n\n进程名字:");
			scanf("%s",&p[i].name);

			printf("到达时间:");
			scanf("%f",&p[i].ddtime);

			printf("运行时间:");
			scanf("%f",&p[i].yxtime);

			printf("  优先数:");
			scanf("%d",&p[i].youxian);

			p[i].sytime=p[i].yxtime;
			p[i].sign=0;
		}
}


void output3(priority *p,int n)//定义输入函数，输入进程的各种信息
{
	int i;
	 printf("\n\n进程的相关信息如下表所示:");
	printf("\n----------------------------------------------------------------------------------------------------------------------");
		printf("\n进程名字\t到达时间\t开始时间\t运行时间\t完成时间\t周转时间\t带权周转\t优先数\n");
	printf("----------------------------------------------------------------------------------------------------------------------");

		   for(i=0;i<n;i++)
		   {printf("\n%s\t\t%.2f\t\t%.2f\t\t%.2f\t\t%.2f\t\t%.2f\t\t%.2f\t\t%d\n",p[i].name,p[i].ddtime,p[i].kstime,p[i].yxtime,p[i].wctime,p[i].zztime,p[i].dqzztime,p[i].youxian);
    printf("----------------------------------------------------------------------------------------------------------------------");}
	printf("\n");

}


void sort3(priority *p,int n)//定义排序函数，按照到达时间从先到后将进程排序
{
	int i,j;
	for(i=0;i<n;i++)
		for(j=i+1;j<n;j++)
			 if(p[i].ddtime>p[j].ddtime)  //如果i的到达时间大于j的到达时间，就交换
			 {
		       priority temp; //定义结构类型的变量，交换时进程内的各种信息都被交换
		       temp=p[i];
		       p[i]=p[j];
		       p[j]=temp;
			 }

	for(i=0;i<n;i++)
		for(j=i+1;j<n;j++)
			 if(p[i].ddtime==p[j].ddtime && p[i].youxian<p[j].youxian)  //如果i和j的到达时间相等，但是优先数不同，则按照优先数进行排列
			 {
		       priority temp; //定义结构类型的变量，交换时进程内的各种信息都被交换
		       temp=p[i];
		       p[i]=p[j];
		       p[j]=temp;
			 }

	  printf("\n进程按照到达时间排序:");
	  for(i=0;i<n;i++)
	      printf("%s  ",p[i].name);
}

void sort4(priority *p,int qq,int zz)//定义排序函数，按照优先数从高到低将进程排序
{
	int i,j;
	for(i=qq+1;i<=qq+zz;i++)  //就绪队列中第一个进程下标qq+1，最后一个进程下标qq+zz
		for(j=i+1;j<=qq+zz;j++)
			 if(p[i].youxian<p[j].youxian)  //如果i的优先数小于j的优先数，就交换
			 {
		       priority temp; //定义结构类型的变量，交换时进程内的各种信息都被交换
		       temp=p[i];
		       p[i]=p[j];
		       p[j]=temp;
			 }
}

void priority(priority *p,int n)//定义优先级函数
{
	int i,j=0,qq,zz=0;

	float nowtime=p[0].ddtime;  //初始化当前时间为第一个进程的到达时间

	for(i=0;i<n;i++)  //循环一次就有一个进程做完
	{
		while(p[i].sign==0)// 进程没有做完就一直循环直到做完
		{

			if(p[i].sytime==0)
			{
				p[i].sign=1;
				p[i].kstime=nowtime;   //开始时间=当前时间
				nowtime+=p[i].yxtime;
				p[i].wctime=nowtime;
					p[i].zztime=p[i].wctime-p[i].ddtime;  //周转时间=完成时间-到达时间
	                        p[i].dqzztime=p[i].zztime/p[i].yxtime;  //带权周转时间=周转时间/运行时间
			}
			else
			{
				p[i].sytime--; //不将其直接设为0，而是要减1，模拟进程不断执行
			}
		} //执行完一个进程，跳出循环

	   zz=0;
	   qq=i;//记录进程的下标           

       for(j=i+1;j<n;j++)//计算此时就绪队列中的进程数
	   {
		   if(p[j].ddtime<=nowtime)
			   zz++;  
	   }
		  
	   if(zz==0)//就绪队列中的进程数为0
	   {
		   nowtime=p[i+1].ddtime;
		   for(j=i+1;j<n;j++)
			   if(p[j].ddtime<=nowtime)
				   zz++;
	   }

	   if(zz>1)
	   sort4(p,qq,zz); //将就绪队列中的进程按照优先级排序
	}
}



void main()
{
int N;//进程的个数
int number=0;
char tishi;

do{
      printf("\n-------------------提示框-------------------\n");
      printf("********************************************\n");
      printf("*******  【先来先服务算法】请输入 1  *******\n");
      printf("*******  【时间片轮转算法】请输入 2  *******\n");
      printf("*******  【优先级调度算法】请输入 3  *******\n");
      printf("********************************************\n");
      printf("\n请选择您的算法：");

    scanf("%d",&number);

    switch(number)
	{
	case 1:
			printf("\n恭喜您选择：【先来先服务算法】\n\n");
			printf("\n请您输入进程的数量：");
			scanf("%d",&N);
			    intput1(a,N);
                sort(a,N);
			    FCFS(a,N);
				output1(a,N);
				break;
	case 2:
			printf("\n恭喜您选择：【时间片轮转算法】\n\n");
			printf("\n请您输入进程数量：");
			scanf("%d",&N);
				intput2(time,N);
				sort2(time,N);
			    RR(time,N);
				output2(time,N);
				break;

	case 3:
		    printf("\n恭喜您选择：【优先级调度算法】\n\n");
			printf("\n请您输入进程数量：");
			scanf("%d",&N);
                intput3(pr,N);
				sort3(pr,N);
			    priority(pr,N);
				output3(pr,N);
			    break;

	default:
		    printf("\n您的输入有误，请确定从1到3之间进行输入，谢谢!!!!!\n");
			    break;	
	}

    printf("\n\n------------------------------------------");
	printf("\n您要继续执行吗？（是请输入y）（否请输入n）");
	printf("\n\n请选择：");
	fflush(stdin);//清空输入缓冲区
	scanf("%c",&tishi);
}while(tishi=='y');

}
jingssshhh
关注
专栏目录
操作系统实习——进程调度算法
qq_45127194的博客
09-13 747
文章目录1 设计内容2 算法原理3 数据结构4 程序流程图5:代码 1 设计内容 设计程序模拟单处理机系统中的进程调度算法，实现动态优先权进程调度算法, 对N个进程采用动态优先权算法的进程调度. 2 算法原理 1．每个用来标识进程的进程控制块PCB，包括以下信息：进程标识数ID，进程优先数PRIORITY，进程已占用的CPU时间CPUTIME，进程还需占用的CPU时间NEEDTIME，进程状态ST...
操作系统进程调度模拟算法（C实现）
CHOCOLATE
07-03 4576
1、“先来先服务”调度算法 编程思路： 对各进程按照到达时间进行排序，挑选最先到达的进程一次性执行完毕，判断是否所有进程都被调度，若是则结束，否则返回挑选最先到达的进程一次性执行完毕步骤，继续执行后续程序。按照进程进入的先后次序来分配处理器。先进入就绪队列的进程优先被挑选，运行进程一旦占有处理器将一直运行下去，直到运行结束或者被阻塞，这是非抢占式调度。 代码如下： //排序: 按照进程的arrivetime（从小到大）对pcb数组中的N个进程进行排序 void sort(pcb *p, int N)
进程调度实习报告
10-09
进程调度模拟程序：假设有10个进程需要在CPU上执行，请实现：  先进先出调度算法；  基于静态优先数的调度算法； 确定这10个进程在CPU上的执行过程。要求每次进程调度时在屏幕上显示：  当前执行进程；  就绪队列；  等待队列
操作系统实践（9）——进程、多进程、系统调用、进程调度
最帅惋红曲
09-01 2070
这一章，与前面提到的特权级转移以及中断处理机制相关的知识关系很大。首先画个图了解下这几个概念的关系以及相互作用：以前一直很想知道系统调用是怎么实现的，看完书才明白系统调用跟普通的中断处理程序实现基本是相似的，可见中断处理程序是本章重点中的重点。梳理一下书中的思路： 1.首先实现一个简单的进程，注册一个时钟中断处理程序，在进程执行的过程中发生时钟中断，执行中断处理程序，返回进程被中断的地方继续执行。
操作系统实习报告（进程管理，进程调度，进程通信）
11-17
这是操作系统，关于进程管理，进程调度，进程通信的报告，包括源码。
操作系统实习 进程调度算法
dawn_1108的博客
07-21 529
操作系统实习 进程调度算法 设计目的： 进程管理是操作系统中的重要功能，用来创建进程、撤消进程、实现进程状态转换，它提供了在可运行的进程之间复用CPU的方法。在进程管理中，进程调度是核心，因为在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态，当就绪进程个数大于处理器数目时，就必须依照某种策略决定哪些进程优先占用处理器。本设计模拟在单处理器情况下的进程调度，加深对进程运行状态和进程调度过...
CPU 时间片轮转机制 (RR 调度)
苞米地里捉小鸡的博客
04-06 2728
时间片轮转机制(RR 调度) 时间片轮转法（Round-Robin，RR）主要用于分时系统中的进程调度。为了实现轮转调度，系统把所有就绪进程按先入先出的原则排成一个队列。新来的进程加到就绪队列末尾。每当执行进程调度时，进程调度程序总是选出就绪队列的队首进程，让它在 CPU 上运行一个时间片的时间。时间片是一个小的时间单位，通常为 10~100ms 数量级。当进程用完分给它的时间片后，系统的计时器...
实习二 进程调度算法的设计（内附代码）
03-08
### 实习二 进程调度算法的设计 #### 一、实习内容 本次实习的主要内容是实现两种进程调度算法：短进程优先调度算法(SPF)和时间片轮转调度算法(RR)。 #### 二、实习目的 通过设计并实现这两种算法，我们可以更...
操作系统进程调度实验
01-27
操作系统课程实习，进程调度实验，用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
操作系统实验之时间轮转算法（数组实现，简单易懂，快速编程）
lvshaoshishang的博客
10-31 431
前段时间上操作系统实验课，刚开始因为懒得写所以直接在CSDN上找代码copy。 但是找了很久发现都有些许bug不能运行出来，一气之下自己动手写了。 看了很多人都是用链表写的，但是由于我上学期数据结构没怎么仔细听课，链表没学好，所以我是用数组写的，我觉得数组更简单易懂。 尚在学习，代码肯定多有不足，望大家指教。 #include<cstdlib> #include<iostream...
操作系统实验（进程调度）
热门推荐
菜鸟一枚
03-02 2万+
操作系统实验（进程调度）一、实验目的二、实验内容三、实验准备3.1优先权算法3.2时间片轮转调度算法四、实验 一、实验目的   1.1理解有关进程控制块、进程队列的概念。   1.2掌握进程优先权调度算法和时间片轮转调度算法的处理逻辑。 二、实验内容   2.1设计进程控制块PCB的结构，分别适用于优先权调度算法和时间片轮转调度算法。   2.2建立进程就绪队列。   2.3编制两种进程调度算法：优先权调度和时间片轮转调度。 三、实验准备 3.1优先权算法   为了照顾紧迫型进程获得优先处理，引入了优先
操作系统实习-进程调度算法（C语言）
weixin_43327389的博客
09-15 4679
文章目录设计目的设计内容设计思路算法流程图程序结构实现代码调试结果 设计目的 进程管理是操作系统中的重要功能，用来创建进程、撤消进程、实现进程状态转换，它提供了在可运行的进程之间复用CPU的方法。在进程管理中，进程调度是核心，因为在采用多道程序设计的系统中，往往有若干个进程同时处于就绪状态，当就绪进程个数大于处理器数目时，就必须依照某种策略决定哪些进程优先占用处理器。本设计模拟在单处理器情况下的...
进程调度算法
AWA124的博客
05-27 477
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; typedef struct node { char name[20]; /*进程的名字*/ int prio; /*进程的优先级*/ int round; ...
【操作系统】进程调度算法-FCFS-SJF-RR
卑微楽的开发之路
12-06 2064
目录 进程调度的概念 引起进程调度的原因 进程调度算法 先来先服务算法(FCFS) 短作业优先算法(SJF) 时间片轮转算法(RR) 进程调度源码 程序源码 运行结果 进程调度的概念 首先我们简洁明了的说, 进程调度就是决定内存中的就绪队列中的那个进程将获得处理机, 进程调度是操作系统中必不可少的一 种调度, 因为我们在电脑上运行的进程很多, 我们在运行进程的...
操作系统实验（一）——进程调度
云杉木屋
11-21 1万+
此文章为关于操作系统实验的讲解，在这一学期，我学习了操作系统，即然学习课程肯定有实验，第一个实验为进程的调度。进程调度有相当多的算法，比如最简单的先来先服务算法，时间片轮转算法，多级队列调度算法等。我将它们中的一部分写进了一个系统用于模拟进程调度，以帮助学习，在这里分享一下我的写法与思路。 当前代码中包含三种算法：先来先服务，短作业优先，高响应比优先。剩余的时间片...
【LeetCode】【算法】136. 只出现一次的数字
passer__jw767的博客
11-12 265
LeetCode 136. 只出现一次的数字
16 合并区间
weixin_47521269的博客
11-12 761
【代码】16 合并区间。
1163：阿克曼(Ackmann)函数
最新发布
呆萌很的博客
11-12 256
1163：阿克曼(Ackmann)函数
数据库范式、MySQL 架构、算法与树的深入解析
lrh35的博客
11-11 1255
在数据库设计中，范式是一系列规则，用于确保数据的组织和存储具有良好的结构、完整性以及最小化的数据冗余。如果不遵循范式设计，数据可能会以平铺式罗列，仅使用冒号、分号等简单分隔。这种方式存在诸多弊端，例如在数据搜索时极为不便，数据修改也会变得十分棘手。由此，范式的概念应运而生。
JOS操作系统实习：多进程调度与IPC实现
操作系统实习lab4是一个综合性的实践项目，它要求学生深入理解操作系统的内核机制，包括进程调度、进程创建、页面管理以及进程间的通信。通过这个实习，学生不仅能提升编程技能，更能对操作系统的核心原理有更直观和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值