操作系统进程调度算法——先来先服务、时间片轮转、优先级调度算法

news2025/4/12 14:12:27

一、先来先服务调度算法

（1）算法内容：先来先服务调度算法是一种最简单的调度算法，可以应用于高级调度也可以运用于低级调度。高级调度时，FCFS调度算法按照作业进入后备作业队列的先后顺序选择作业进入内存，即先进入后备作业队列的作业被优先选择进入内存，然后为选中的作业创建进程并分配该作业所需资源。低级调度时，FCFS调度算法每次从内存的进程/线程就绪队列中选择一个最先进入的进程/线程，然后由进程/线程调度程序将CPU分配给它并使其运行。

（2）算法要求：每个进程由一个进程控制快（PCB）表示。进程控制块可以包含如下信息：进程名，到达时间，运行时间，开始时间，完成时间，等待时间，周转时间，代权周转时间等。先进入就绪队列的进程，先分配处理机运行。一旦一个进程占有了处理机，它就一直运行下去，直到该进程完成工作或者因为等待某事件发生而不能继续运行时才释放处理机。

（3）设计思想：该算法按照进程到达时间先后顺序执行，先到达的先执行。

（4）算法分析：先定义一个PCB结构体；

定义input()输入函数，输入进程号、到达时间、运行时间；

定义output()输出函数，输出每个进程块的各种时间；

定义rank()排序函数，将进程按照到达时间进行排序；

定义FCFS()先来先服务算法函数，计算各种时间；

定义main()主函数，实现先来先服务功能；

（5）核心代码：

#include<stdio.h>
    double atime;            //平均周转时间 
	double awtime;    //平均带权周转时间
struct PCB     //声明结构体类型PCB 
{
	char name[20];          //进程号 
	int arrivaltime;       //到达时间 
	int runtime;           //运行时间 
	int starttime;         //开始时间 
	int finishtime;        //完成时间 
	int waitingtime;       //等待时间 
	int cycletime;        //周转时间 
	double wctime;        //带权周转时间 
};
struct PCB pcb[100];
/*输入函数*/ 
int input(int n)   
{
	printf("请依次输入进程号、到达时间、运行时间：\n");
	for(int i=0;i<n;i++)
	{
		scanf("%s\t%d\t%d",pcb[i].name,&pcb[i].arrivaltime,&pcb[i].runtime);
	}
 } 
 /*输出函数*/ 
int output(int n)  
{
	printf("\n======================================================================================================================\n");
	printf("进程号 \t到达时间\t运行时间\t开始时间\t完成时间\t等待时间\t周转时间\t带权周转时间\n");
	printf("----------------------------------------------------------------------------------------------------------------------\n");
	for(int i=0;i<n;i++)
	{
	printf("%3s\t  %d\t\t   %d\t\t   %d\t\t   %d\t\t   %d\t\t   %d\t\t   %.2lf\n",pcb[i].name,pcb[i].arrivaltime,pcb[i].runtime,pcb[i].starttime,pcb[i].finishtime,pcb[i].waitingtime,pcb[i].cycletime,pcb[i].wctime);
	}
	printf("----------------------------------------------------------------------------------------------------------------------\n");
	printf("\t平均周转时间    \t\t%.2lf\t\n",atime);
	printf("----------------------------------------------------------------------------------------------------------------------\n");
	printf("\t平均带权周转时间\t\t%.2lf\t\n",awtime);
	printf("======================================================================================================================\n"); 
}
/*按到达时间进行排序*/ 
int rank(int n)
{
	struct PCB t;
	for(int j=0;j<n-1;j++)  //冒泡法排序
	for(int i=0;i<n-1-j;i++)
    {
    	if(pcb[i].arrivaltime>pcb[i+1].arrivaltime)
		{
			t=pcb[i];
			pcb[i]=pcb[i+1];
			pcb[i+1]=t;
		} 
	}
}
/*先来先服务算法*/
int FCFS(int n)
{
/*完成时间*/
	if(pcb[0].arrivaltime!=0) //第一个进程到达时间不为0时，其完成时间=开始时间+运行时间
	{
		pcb[0].finishtime=pcb[0].starttime+pcb[0].runtime;
	}
	else
		pcb[0].finishtime=pcb[0].runtime; //第一个进程到达时间为0时，其完成时间=运行时间
		for(int i=1;i<n;i++)
		{
			if(pcb[i-1].finishtime>=pcb[i].arrivaltime) //如果前一个进程的完成时间大于等于当前进程的到达时间
			{
				pcb[i].finishtime=pcb[i-1].finishtime+pcb[i].runtime; //当前进程的完成时间=前一个进程的完成时间+该进程的运行时间
			 } 
			else
			{
				pcb[i].finishtime=pcb[i].arrivaltime+pcb[i].runtime; //否则为当前进程的到达时间+运行时间
			}
		 }
 /*开始时间*/ 
	pcb[0].starttime=pcb[0].arrivaltime; //第一个进程的开始时间即到达时间
	for(int i=1;i<n;i++)
	{
		pcb[i].starttime=pcb[i-1].finishtime; //从第二个进程开始，开始时间=前一个进程的完成时间
	}
/*等待时间 周转时间 带权周转时间*/
 	for(int i=0;i<n;i++) 
 	{
 		pcb[i].waitingtime=pcb[i].starttime-pcb[i].arrivaltime; //等待时间=开始时间-到达时间
pcb[i].cycletime=pcb[i].finishtime-pcb[i].arrivaltime; //周转时间=完成时间-到达时间
pcb[i].wctime=pcb[i].cycletime/(pcb[i].runtime*1.0); //带权周转时间=周转时间/运行时间
	 }
/*平均周转时间 平均带权周转时间*/
int sum1=0;
double sum2=0;
for(int i=0;i<n;i++)
		{
			sum1+=pcb[i].cycletime;    //求所有进程周转时间的和
sum2+=pcb[i].wctime;      //求有所进程周转时间的和
		}
		atime=sum1/(n*1.0);   //平均周转时间=所有进程周转时间的和/进程数
awtime=sum2/n;       //平均带权周转时间=所有进程周转时间的和/进程数 
	}
	/*主函数*/ 
int main()
{
	printf("先来先服务FCFS算法模拟\n请输入进程个数：\n");
    int n;
    scanf("%d",&n);  //输入进程数 n
input(n);       //输入函数
rank(n);        //排序函数，按到达时间给各进程排序 （升序）
    FCFS(n);         //先来先服务算法函数，计算各种时间
    output(n);       //输出函数
    return 0;
}

（6）测试数据或截图：

 （6）运行结果分析：根据先来先服务算法，首先按到达时间大小将其排序，根据进程的输入信息，第一个进程a到达时间为0，其完成时间=运行时间=1，其余进程的完成时间=前一个进程的完成时间+该进程的运行时间，（如，b的完成时间=1+100=101，c的完成时间=101+1=102，d的完成时间=102+100=201）；第一个进程a的开始时间=到达时间=0，其余进程的开始时间=前一个进程的完成时间，（如，b的开始时间=a的完成时间=1，c的开始时间=b的完成时间=101，d的开始时间=c的完成时间=102）；每个进程的等待时间=开始时间-到达时间（如，a的等待时间=0-0=0，b的等待时间=1-1=0，c的等待时间=101-2=99，d的等待时间=102-3=99）；周转时间=完成时间-到达时间（如，a的周转时间=1-0=1，b的周转时间=101-1=100，c的周转时间=102-2=100，d的周转时间=202-3=199）；带权周转时间=周转时间/运行时间（如，a的带权周转时间=1/1=1，b的带权周转时间=100/100=1，c的带权周转时间=100/1=100，d的带权周转时间=199/100=1.99）；平均周转时间=所有进程周转时间的和/进程数(1+100+100+199)/4=100；平均带权周转时间=所有进程带权周转时间的和/进程数（1+1+100+1.99）/4=26。

二、时间片轮转调度算法

（1）算法内容：时间片轮转调度算法主要用于低级调度，调度方式实际上是一种基于时钟的抢占式调度算法。在采用时间片轮转调度算法的系统中，进程/线程就绪队列按到达时间的先后次序进行排队，按照先来先服务原则，将需要执行的所有进程按照到达时间大小排成一个升序的序列，每次都给一个进程同样大小的时间片，在这个时间片内如果进程执行结束了，那么把进程从进程队列中删去，如果进程没有结束，那么把该进程停止然后改成等待状态，放到进程队列的尾部，直到所有的进程都已执行完毕。

（2）算法要求：每个进程由一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名，到达时间，运行时间，完成时间，周转时间，带权周转时间，完成进程标志，剩余服务时间等。进程的运行时间以时间片为单位进行计算。

（3）设计思想：每次调度时，总是选择就绪队列的队首进程，让其在CPU上运行一个系统预先设置好的时间片。一个时间片内没有完成运行的进程，返回到绪队列末尾重新排队，等待下一次调度。时间片轮转调度属于抢占式调度，适用于分时系统。

（4）算法分析：先定义一个RR结构体；

input()输入函数；

rank()函数对进程到达时间排序；

rr_pcb()函数执行轮转调度算法；

output()输出函数；

main()主函数。

（5）核心代码：

#include<stdio.h>
   double atime;            //平均周转时间 
   double awtime;    //平均带权周转时间
 struct RR
 {
 	char name[20];         //进程号 
 	int arrivaltime;       //到达时间 
	int runtime;           //运行时间
	int starttime;         //开始时间 
	int finishtime;        //完成时间
	int cycletime;      //周转时间 
	double wctime;      //带权周转时间
	int sign;          //完成进程标志 
	int st1;    //剩余服务时间 
  };
  struct RR rr[100];
  /*输入函数*/ 
int input(int n)
{
	printf("请依次输入进程号、到达时间、运行时间：\n");
	for(int i=0;i<n;i++)
	{
		rr[i].sign=0; 
		scanf("%s\t%d\t%d",rr[i].name,&rr[i].arrivaltime,&rr[i].runtime);
		rr[i].st1=rr[i].runtime;
	} 
}
/*采用冒泡法，按进程的到达时间对进程进行排序*/
int rank(int n)
{
	int i,j;
	struct RR temp; 
	for(j=0;j<n-1;j++)
	for(i=0;i<n-1-j;i++)
	{
		if(rr[i].arrivaltime>rr[i+1].arrivaltime)
		{
			temp=rr[i];
			rr[i]=rr[i+1];
			rr[i+1]=temp;
		}
	}
}
/*执行时间片轮转调度算法*/ 
int rr_pcb(int n)  
{
	printf("请输入时间片：\n");
	int t;
	scanf("%d",&t);  //输入时间片
	int time=rr[0].arrivaltime;     //给当前时间time赋初值
	int flag=1;          //标志就绪队列中有进程
	int sum=0;          //记录完成的进程数
	printf("\n====================================================================================================================\n");
	printf("进程号 \t到达时间\t运行时间\t开始时间\t完成时间\t周转时间\t带权周转时间\n");
	printf("--------------------------------------------------------------------------------------------------------------------\n");
	while(sum<n) //当完成的进程数小于进程总数
	{
	flag=0;    //标记就绪队列没有进程
	for(int i=0;i<n;i++) //时间片轮转法执行各进程 
	{
		if(rr[i].sign==1)//已完成进程 
		continue;
		else//未完成的进程
		{
			if(rr[i].st1<=t && time>=rr[i].arrivaltime)//还需运行的时间小于等于一个时间片 
			{
	 	      flag=1;  //把进程加入到就绪队列中
	       	  time+=rr[i].st1;
	 	      rr[i].sign=1; //此进程完成
	          rr[i].finishtime=time;  //完成时间 
              rr[i].cycletime=rr[i].finishtime-rr[i].arrivaltime;  //计算周转时间=完成时间-到达时间 
			  rr[i].wctime=rr[i].cycletime/(rr[i].runtime*1.0);   //计算带权周转时间=周转时间/服务 
			  printf("%3s\t  %d\t\t   %d\t\t   %d\t\t   %d\t\t   %d\t\t   %.2lf\n",rr[i].name,
	rr[i].arrivaltime,rr[i].runtime,time-rr[i].st1,time,rr[i].cycletime,rr[i].wctime);
			}		 	    
			else if(rr[i].st1>t&&time>=rr[i].arrivaltime)    //还需服务时间至少大于一个时间片 
			{
	 		  flag=1;  //把进程加入到就绪队列中
	 		  time+=t;
			  rr[i].st1-=t;
              rr[i].cycletime=rr[i].finishtime-rr[i].arrivaltime; //计算周转时间=完成时间-到达时间 
			  rr[i].wctime=rr[i].cycletime/(rr[i].runtime*1.0);  //计算带权周转时间=周转时间/服务
			  printf("%3s\t  %d\t\t   %d\t\t   %d\t\t   %d\t\t   %d\t\t   %.2lf\n",rr[i].name,
	rr[i].arrivaltime,rr[i].runtime,time-t,time,rr[i].cycletime,rr[i].wctime);
			} 
	    	if(rr[i].sign==1)
 		       sum++;     //一个进程执行完就+1
		} 
	 } 
	} 
	/*平均周转时间  平均带权周转时间*/ 
	int sum1=0;
	double sum2=0;
	for(int i=0;i<n;i++)
	{
		
		sum1+=rr[i].cycletime;  //求所有进程周转时间的和 
		sum2+=rr[i].wctime;  //求所有进程带权周转时间的和 
	}
	atime=sum1/(n*1.0);  //平均周转时间=有进程周转时间的和/进程数 
	awtime=sum2/n;   //平均带权周转时间=所有进程带权周转时间的和/进程数 
 } 
 /*输出函数*/
 int output(int n)
 {
    printf("--------------------------------------------------------------------------------------------------------------------\n");
	printf("\t平均周转时间    \t\t%.2lf\t\n",atime);
	printf("--------------------------------------------------------------------------------------------------------------------\n");
	printf("\t平均带权周转时间\t\t%.2lf\t\n",awtime);
	printf("====================================================================================================================\n"); 
}
/*主函数*/
int main()
{
	printf("时间片轮转调度算法\n请输入总进程数：\n");
	int n;
	scanf("%d",&n);   //输入总进程数 
	input(n);   //输入函数 
	rank(n);    //排序函数 
	rr_pcb(n);   //计算各时间 
	output(n);   //输出函数 
	return 0;
 }

（6）测试数据或截图：（时间片为1的见图1，时间片为5的见图2）

图1 时间片=1时运行结果截图

图2 时间片=5时运行结果截图

（7）运行结果分析：执行时间图像如下，

图4-24 执行时间图像

时间片=1时，a、b、c、d四个进程的运行时间都大于规定的时间片，一个时间片内没有完成运行，则都需要返回就绪队列的队尾，等待下一次调度继续执行。CPU被分配给当前就绪队列的第一个进程。

时间片=5时，第一个进程的运行时间等于20>5，一个时间片内没有完成运行，则进程a返回到就绪队列末尾重新排队，等待下一次调度；第二个进程的运行时间等于10>5，用完了规定的时间片，则进程b返回到绪队列末尾，等待再次被调度执行；第二个进程的运行时间等于15>5，则进程c返回到就绪队列的队尾，等到下一次轮转到自己时再投入运行；第四个进程的运行时间为5，刚好在一个时间片内完成运行，则进程d放弃CPU的使用权。此时，进程调度程序又将CPU分配给当前就绪队列的第一个进程，即进程a。

三、优先级调度算法

（1）算法内容：优先级调度算法既可以应用于高级调度（作业调度）也可以应用于低级调度（进程调度），还可用于实时系统。高级调度时，优先数调度算法每次从后备作业队列中选择优先级最高的作业调入内存，为其分配相应的资源并创建进程放入到进程就绪队列中。低级调度时，优先级调度算法每次从进程就绪队列中选择优先级最高的进程为其分配CPU而投入运行。如果有多个优先级最高的作业/进程，则可结合先来先服务或短作业/短进程优先调度策略。

（2）算法要求：每个进程由一个进程控制块（PCB）表示。进程控制块可以包含如下信息：进程名，运行时间，优先数，进程状态等。进程的优先数及需要运行时间可以事先人为指定（也可由随机数产生）。每个进程的状态可以是就绪W（Wait）,运行R（Run）或者完成F（Finish）3个状态之一。

（3）设计思想：采用抢占式优先级调度算法，具有最高级优先级的就绪进程/线程首先得到CPU运行，并在运行过程中允许被具有更高优先级的就绪进程/线程抢占CPU。如果有多个优先级最高的进程，则结合先来先服务调度策略。每次运行之前，为每个进程任意确定它的“优先数”和“要求运行时间”。处理器总是选队首进程运行。采用动态改变优先数的办法，进程每运行1次，优先数减1，要求运行时间减1。进程运行一次后，若要求运行时间不等于0，则将它加入队列，否则，将状态改为“结束”，退出队列。若就绪队列为空，结束，否则重复上述步骤。

（4）算法分析：定义进程控制块；

input()函数;

output()函数；

max_priority()函数找出就绪态中优先级最高的进程；

psa_pcb()函数为优先级调度算法；

main()主函数；

（5）核心代码：

#include<stdio.h>
/*结构体*/
struct PSA
{
char name[10];      //进程名
int runtime;       //运行时间
int priority;      //优先数
char state;        //状态，三状态：W-就绪；R-运行；F-结束
};
struct PSA psa[10];   //定义进程控制块数组

/*输入函数*/
int input(int n)
{ 
printf("请输入PCB的进程名，运行时间，优先数:\n");
for(int i=0;i<n;i++)    //i为进程编号
{
scanf("%s\t%d\t%d",&psa[i].name,&psa[i].runtime,&psa[i].priority);
psa[i].state=‘W’;    //初始状态都设为就绪
getchar();
}
}
/*输出函数*/
int output(int n)
{ 
printf("\n==============================\n");
printf("进程号 运行时间 优先数 状态\n");
printf("------------------------------\n");
for(int i=0;i<n;i++)
printf("%s %7d%9d\t%s\n",psa[i].name,psa[i].runtime,psa[i].priority,&psa[i].state);
printf("==============================\n");
}
/*进程在就绪状态时找出最大优先数进程（返回值为最大优先数编号）*/
int max_priority(int n)
{
int max=-1;    //max为最大优先数
int m;     //m为最大优先数进程的编号
for(int i=0;i<n;i++)
{      //进程在就绪状态时找出最大优先数
if(psa[i].state==‘R’)    //进程在运行状态
return -1;
else if((max<psa[i].priority)&&(psa[i].state==‘W’)) //进程在就绪状态
{
max=psa[i].priority;
m=i;     //把最大优先数对应的编号赋给m
}
}
//确保最大优先数进程还没结束运行
if(psa[m].state==‘F’) //最大优先数进程已结束运行
return -1;
else //最大优先数进程还没结束运行
return m; //返回值为最大优先数编号
}
/*优先数调度算法*/
int psa_pcb(int n)
{
int max_time=-1,m=0;
int sum=0;    //sum为程序总运行次数
for(int i=0;i<n;i++)
sum+=psa[i].runtime;
printf("\n初始时各进程信息如下:\n");
output(n);
getchar();
for(int j=0;j<sum;j++)
{
//当程序正在运行时
while(max_priority(n)!=-1)    //max_priority ()为找出最大优先数进程函数，返回最大值对应的编号m
{
if(psa[max_priority(n)].priority!=0)
psa[max_priority(n)].state=‘R’;    //由就绪转为运行态
else
{ //当优先级降为0，进程还没运行完时
for(int i=0;i<n;i++)
if(max_time<psa[i].runtime)
{
max_time=psa[i].runtime;
m=i;    //返回对应的编号
}
max_time=-1;
psa[m].state=‘R’;    //状态转为运行态
}
}
    //判断程序状态(对优先数和运行时间操作) 
    for(int i=0;i<n;i++)
    {
        if(psa[i].state==‘R’)   //当进程处于运行状态时 
        {
            if(psa[i].priority>0)     //优先数>0
               psa[i].priority--;  //每运行一次优先数-1
            psa[i].runtime--;   //每运行一次运行时间-1
        }
        if(psa[i].runtime==0)  //运行时间完
			psa[i].state=‘F’;   //进程状态转为完成状态
        else     //运行时间没完
			psa[i].state=‘W’;   //进程状态转为就绪状态
    } 
    output(n);
    getchar();
}    
}
/*主函数*/
int main()
{
	printf("优先数调度算法：\n输入总进程数：\n");
	int n;
	scanf("%d",&n);   //输入总进程数n
    input(n);    //输入函数
    psa_pcb(n);   //优先数调度算法
    return 0;
}

 
（6）测试数据或截图：

  


 

（7）运行结果分析：初始时，a、b、c、d、e五个进程的状态都是就绪态（W），其中c的优先级最大，则c首先得到CPU运行，其运行时间为2，在运行状态时运行时间减1，优先数减1；进程a的运行时间为0，此时a的状态由就绪态变为完成态；之后c、e的优先数都是最大的，但根据先来先服务调度策略，c先处于运行态，优先数减1，运行时间减1为0，所以c变成完成态；此时只有b、d、e三个进程处于就绪态，其中e的优先数最大，则e获得CPU投入运行，其运行时间减1，优先数减1；然后b和e的优先数都一样大，根据先来先服务调度策略，则b抢占CPU处于运行态，运行时间减1为0，则b变成完成态；此时只剩下d和e两个进程，e的优先数较大，则e抢占CPU处于运行态，优先数和运行时间减1；e优先数减1后与d的一样大，但根据先来先服务原则，d先获得CPU，处于运行态，优先数和运行时间减1；此刻，e的优先数比d大，故e得到CPU运行，运行时间和优先数减1；d和e的优先数又是一样大，但d先运行，运行时间和优先数减1，则e优先数大于d，e获得CPU，运行时间减1为0，e处于完成态；最后只剩d获得CPU运行，运行时间减1为0，变成完成态。总之，优先级高的进程先获得CPU处于运行态，运行一次后，运行时间与优先数减1,当运行时间不为0时加入就绪队列，运行时等于0时状态改为结束（F）。如果有多个优先级一样高的进程，则根据先来先服务原则处理。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/542449.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

FL Studio 20汉化补丁及详细激活使用说明/fl studio21怎么设置中文？

FL Studio 20汉化补丁及详细激活使用说明/fl studio21怎么设置中文？

音乐在人们心中的地位日益增高&#xff0c;近几年音乐选秀的节目更是层出不穷&#xff0c;喜爱音乐&#xff0c;创作音乐的朋友们也是越来越多&#xff0c;音乐的类型有很多&#xff0c;好比古典&#xff0c;流行&#xff0c;摇滚等等。对新手友好程度基本上在首位&#xff0c;…
阅读更多...
AI新风向标PaLm2？能否取代ChatGPT成为AI领域的老大

AI新风向标PaLm2？能否取代ChatGPT成为AI领域的老大

AI新风向标PaLm2&#xff1f; ​ 前几天Google发布了&#xff0c;PaLM2作为Google的下一代大型语言模型&#xff0c;它会取代ChatGPT成为更智能的AI工具吗? 关于PaLM2 ​ PaLM 2是Google的下一代大型语言模型&#xff0c;它建立在谷歌在机器学习和负责任的人工智能方面的突破…
阅读更多...
新一代硬件安全第5章 TRNG

新一代硬件安全第5章 TRNG

title: “第5章 真随机数生成器的本征熵” author: date: 2023-05-18 output: word_document Chapter 5 Intrinsic Entropy for True Random Number Generation 5.1 Chapter Introduction True Random Number Generators (TRNGs) form an essential and indispensable part …
阅读更多...
【LLM系列之底座模型对比】LLaMA、Palm、GLM、BLOOM、GPT模型结构对比

【LLM系列之底座模型对比】LLaMA、Palm、GLM、BLOOM、GPT模型结构对比

LLama [GPT3] 使用RMSNorm&#xff08;即Root Mean square Layer Normalization&#xff09;对输入数据进行标准化&#xff0c;RMSNorm可以参考论文&#xff1a;Root mean square layer normalization。[PaLM]使用激活函数SwiGLU&#xff0c; 该函数可以参考PALM论文&#xff…
阅读更多...
Java:异常

Java:异常

异常:就是代表程序出现的问题 作用&#xff1a; 作用一:异常是用来查询bug的关键参考信息作用二:异常可以作为方法内部的一种特殊返回值&#xff0c;以便通知调用者底层的执行情况&#xff08;抛异常&#xff09; 1.Error:代表的系统级别错误 &#xff08;属于严重问题) 2.…
阅读更多...
Jetpack Compose中的列表控件LazyRow和LazyColumn详解

Jetpack Compose中的列表控件LazyRow和LazyColumn详解

背景 如果你需要显示大量的条目&#xff08;或一个未知长度的列表&#xff09;&#xff0c;使用像 Column 这样的布局会导致性能问题&#xff0c;因为所有的条目都会被组合和布局&#xff0c;无论它们是否可见。那么&#xff0c;在Compose中有没有像RecycleView的控件可以滑动…
阅读更多...
python类的高级函数

python类的高级函数

类的高级函数 __str__ 如果定义了该函数&#xff0c;当print当前实例化对象的时候&#xff0c;会返回该函数的return信息 用法&#xff1a; def __str__(self): return str_type 参数&#xff1a;无 返回值&#xff1a;一般返回对于该类的描述信息 __getattr__ 当调用的…
阅读更多...
C++类模板——嵌套使用

C++类模板——嵌套使用

目录 类模板的嵌套分类 一、数组的成员是栈 &#xff08;一&#xff09;Vector大小为2&#xff0c;Stack大小为3&#xff1b;不对Vector进行扩展&#xff1b;&#xff08;浅拷贝&#xff09;&#xff0c;只对C内置数据类型进行拷贝 1&#xff09;代码 2&#xff09;注意事…
阅读更多...
代码随想录算法训练营第四十五天 | dp最小值题目

代码随想录算法训练营第四十五天 | dp最小值题目

70. 爬楼梯 的改进版 改进条件 改为&#xff1a;一步一个台阶&#xff0c;两个台阶&#xff0c;三个台阶&#xff0c;…&#xff0c;直到 m个台阶。问有多少种不同的方法可以爬到楼顶呢&#xff1f; 文档讲解&#xff1a;代码随想录 (programmercarl.com) 状态&#xff1a;能…
阅读更多...
IS420ESWBH3A DIN导轨或潜在面板安装

IS420ESWBH3A DIN导轨或潜在面板安装

马克维耶斯IONet交换机IS420ESWBH3A由通用电气公司生产&#xff0c;工作在24/28 VDC&#xff0c;这种型号没有任何光纤端口&#xff0c;但有16个铜端口。IS420ESWBH3A开关在DIN导轨安装时需要安装夹&#xff0c;在面板安装时只需要螺钉。 IS420ESWBH3A技术规范 光纤端口数量没…
阅读更多...
chatgpt赋能Python-python3_10安装numpy

chatgpt赋能Python-python3_10安装numpy

Python3.10安装numpy&#xff1a;一步一步教你如何轻松完成 Python3.10虽然已经发布了&#xff0c;但是有些模块还需要手动安装&#xff0c;例如numpy。在这篇文章中&#xff0c;我们将会详细介绍如何安装numpy模块&#xff0c;以及为什么要使用numpy模块。 什么是numpy模块&…
阅读更多...
Redis教程-基础篇

Redis教程-基础篇

第一部分&#xff1a;入门 1.1 Redis简介 Redis&#xff08;Remote Dictionary Server&#xff09;是一个高性能的键值存储系统&#xff0c;它是一种开源、基于内存的数据结构服务器。Redis以其出色的性能和灵活的数据结构而受到广泛关注和应用。下面展开描述Redis的定义和特…
阅读更多...
chatgpt赋能Python-python3gui

chatgpt赋能Python-python3gui

Python3 GUI- 让你的应用程序更酷炫 随着技术的发展&#xff0c;图形用户界面(Graphical User Interface, GUI)已经成为软件开发过程中不可或缺的一部分。Python3是一个用于快速开发应用程序的强大编程语言&#xff0c;支持多种GUI库。本文将为您介绍Python3 GUI的一些基本概念…
阅读更多...
web安全第一天 ，域名，dns

web安全第一天 ，域名，dns

第一天 什么是域名&#xff1f;域名就是网络地址 在hhtp之后的就是域名 域名在哪里注册呢 国内注册商有很多&#xff0c;在网络上搜索一下阿里云万网就可以注册 什么是二级域名和多级域名 域名通常都是www.开头 &#xff0c;而www.被称为顶级域名&#xff0c;在搜索的时候…
阅读更多...
【云计算与虚拟化】第五章 实验一 vCenter Server的高级功能—vMotion、虚拟内存、虚拟CPU、磁盘分配及资源池

【云计算与虚拟化】第五章 实验一 vCenter Server的高级功能—vMotion、虚拟内存、虚拟CPU、磁盘分配及资源池

实验一 vCenter Server的高级功能—vMotion、虚拟内存、虚拟CPU、磁盘分配及资源池 1.通过vSphere client 客户端登陆vCenter服务器 &#xff08;1&#xff09;再次新建一个共享存储&#xff0c;iSCSI类型的&#xff0c;大小60G&#xff0c;名称为iSCSI-2。 &#xff08;2…
阅读更多...
C++模板类与函数

C++模板类与函数

目录 分类 一、普通函数&#xff0c;参数和返回值是模板类的实例化版本&#xff08;只支持AA模板类的某一个具体化类&#xff09; 1&#xff09;代码 2&#xff09;分析 3&#xff09;运行结果 二、函数模板&#xff0c;参数和返回值是某种模板类&#xff08;只支持AA模板…
阅读更多...
chatgpt赋能Python-python31个关键词

chatgpt赋能Python-python31个关键词

Python 31个关键词: 了解Python编程的基础知识 Python是一种高级编程语言&#xff0c;首次推出于1991年。自那时以来&#xff0c;Python已经成为最受欢迎的编程语言之一&#xff0c;它具有易读性、易维护性和清晰的语法。在这篇文章中&#xff0c;我们将介绍Python的31个关键词…
阅读更多...
python3.8 安装 ssl 模块 和 _ctypes 模块

python3.8 安装 ssl 模块 和 _ctypes 模块

文章目录 前情提要安装 openssl-1.1.1重新编译安装 python3.8-rpath 编译选项介绍python3.8 跟 python3.10 的区别 前情提要 在我成功给 python3.10 安装 ssl 模块后自以为是的写下了 “虽然我编译的是 python3.10&#xff0c;但是对于 python3.6、python3.8 应该同样适用。”…
阅读更多...
chatgpt赋能Python-python3_0怎么安装

chatgpt赋能Python-python3_0怎么安装

Python3.0怎么安装 Python3.0是一个优秀的编程语言&#xff0c;其简单易学&#xff0c;易用性强&#xff0c;且具有强大的功能和广泛的应用。如果您需要在您的电脑上使用Python3.0&#xff0c;本文将为您介绍如何进行安装。 下载Python3.0 首先&#xff0c;您需要从官方网站…
阅读更多...
教育不得不改变，ChatGPT可以提供个性化学习

教育不得不改变，ChatGPT可以提供个性化学习

近日&#xff0c;OpenAI的首席执行官Sam Altman接受ABC新闻首席商业、技术和经济记者Rebecca Jarvis的独家采访。Sam Altman提到了对错误信息的担忧、探讨了人工智能与人类工作的关系、ChatGPT与教育的关系等。 ChatGPT今年1月面世后&#xff0c;在短短几个月内就达到了1亿月活…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023