调度算法

合集下载

分布式系统中的任务调度算法

分布式系统中的任务调度算法

分布式系统中的任务调度算法1. 轮询调度算法(Round Robin):将任务按顺序分配给所有可用的计算节点,每个节点依次接收任务直到全部节点都接收到任务,然后重新开始分配。

这种调度算法简单易实现,但不能根据节点负载情况做出合理调度决策。

2. 随机调度算法(Random):随机选择一个可用的计算节点,将任务分配给它。

这种调度算法简单高效,但不能保证节点的负载平衡。

3. 加权轮询调度算法(Weighted Round Robin):为每个计算节点设置一个权重值,根据权重值的大小将任务分配给相应的计算节点。

这种调度算法可以根据节点的性能和资源情况进行灵活调整,实现负载均衡。

4. 最小任务数优先算法(Least Task First):选择当前任务最少的计算节点,将任务分配给它。

这种调度算法可以实现最小负载优先策略,但不能考虑计算节点的性能差异。

1. 最短任务时间优先算法(Shortest Job First):根据任务的处理时间,选择处理时间最短的计算节点,将任务分配给它。

这种调度算法可以最小化任务的执行时间,但无法适应节点负载波动的情况。

2. 最靠近平均负载算法(Nearest Load First):选择负载最接近平均负载的计算节点,将任务分配给它。

这种调度算法可以实现负载均衡,但每次任务调度需要计算计算节点的负载,并更新平均负载值,造成一定的开销。

3. 动态加权轮询调度算法(Dynamic Weighted Round Robin):根据各个计算节点的负载情况动态调整其权重值,实现负载均衡。

这种调度算法能够根据系统负载情况作出灵活调度决策,并适应系统负载波动的情况。

4. 自适应任务调度算法(Adaptive Task Scheduling):根据任务的执行状态动态调整任务分配策略。

这种调度算法可以根据任务执行情况实时调整任务分配,提高系统的性能和吞吐量。

1.基于遗传算法的任务调度算法:将任务调度问题建模为一个优化问题,并使用遗传算法等优化算法进行求解。

常用的调度算法

常用的调度算法

常用的调度算法调度算法是指操作系统中用于决定进程何时执行、何时暂停等的一种算法。

常用的调度算法包括先来先服务(FCFS)、短作业优先(SJF)、优先级调度、时间片轮转等。

下面将对这些常用的调度算法进行详细介绍。

一、先来先服务(FCFS)先来先服务是最简单的调度算法之一,它按照进程到达的顺序进行调度,即谁先到谁先执行。

这种算法容易实现,但是存在“饥饿”现象,即如果某个进程长时间等待,则其他进程可能会一直占用CPU资源,导致该进程无法得到执行。

因此,在实际应用中,FCFS很少被使用。

二、短作业优先(SJF)短作业优先是一种以作业运行时间为依据的调度算法。

它通过预测每个进程需要运行的时间,并将其按照运行时间从小到大排序,然后依次执行。

这种算法可以最大限度地减少平均等待时间和平均周转时间,并且不会出现“饥饿”现象。

但是,在实际应用中,由于很难准确预测每个进程需要运行的时间,因此SJF也存在缺陷。

如果预测不准确,那么就会出现长作业等待短作业的情况,导致长作业的等待时间变长。

三、优先级调度优先级调度是一种按照进程优先级进行调度的算法。

每个进程都有一个优先级,系统会根据进程的优先级来决定下一个要执行的进程。

通常情况下,优先级越高的进程越有可能得到CPU资源。

但是,如果某个进程的优先级一直比其他进程高,那么其他进程就会一直等待,导致“饥饿”现象。

此外,在实际应用中,由于不同进程之间的优先级差别较大,因此可能会导致低优先级的进程长时间等待。

四、时间片轮转时间片轮转是一种按照时间片进行调度的算法。

它将CPU资源划分成若干个时间片,并将每个时间片分配给一个正在运行或等待运行的进程。

当一个进程用完了它所分配到的时间片后,系统会将其挂起,并将CPU资源分配给下一个等待运行的进程。

这种算法可以避免“饥饿”现象,并且能够保证所有正在运行或等待运行的进程都能够得到CPU资源。

但是,如果时间片太小,会导致进程频繁切换,影响系统性能;如果时间片太大,会导致长作业等待时间变长。

调度算法

调度算法

3.多级反馈队列调度算法的性能
多级反馈队列调度算法具有较好的性能,能很好地满足各
种类型用户的需要 (1) 终端型作业用户(备注1) (2) 短批处理作业用户(2) (3) 长批处理作业用户(3)
3.4 实 时 调 度
3.4.1 实现实时调度的基本条件 1.提供必要的信息 (1) 就绪时间(任务成为就绪状态的起始时间) (2) 开始截止时间和完成截止时间 (3) 处理时间(一个任务从开始执行直至完成所需的时间) (4) 资源要求(任务执行时所需的一组资源) (5) 优先级(若任务的开始截止时间错过会引起故障,则赋予 该任务“绝对”优先级;若对任务的继续运行影响不大,则赋予 “相对”优先级,供调度程序参考。)
硬实时调度算法和软实时调度算法
根据调度方式的不同: 非抢占调度算法和抢占调度算法 根据调度时间的不同:
静态调度算法和动态调度算法,前者是指在进程执行前,调度
程序便已经决定了各进程间的执行顺序,而后者则是在进程的 执行过程中,由调度程序届时根据情况临时决定将哪一进程投 入运行。
在多处理机环境下,还可将调度算法分为集中式调度
1) 基于时钟中断的抢占式优先权调度算法 只有等到时钟中断到来时,调度程序才能剥夺当前任务的 执行,将处理机分配给新到的高优先权的任务。该算法效 果良好,可用于大多数实时系统。 2) 立即抢占的优先权调度算法 在这种调度策略中,一旦出现外部中断,只要当前任务未 处于临界区,便立即剥夺当前任务的执行,把处理机分配 给请求中断的紧迫任务。响应速度十分快,可把调度延迟 降低到几毫秒至100us。 下图给出了四种调度算法的调度情况
4.具有快速切换机制
为保证要求较高的硬实时任务能及时运行,在实时系统中还应具有快速切

操作系统的调度算法优先级时间片和占式调度

操作系统的调度算法优先级时间片和占式调度

操作系统的调度算法优先级时间片和占式调度操作系统的调度算法:优先级、时间片和抢占式调度操作系统是计算机系统中的一个核心组件,用于管理和控制计算机的硬件和软件资源,以提供良好的用户体验和系统性能。

在操作系统中,调度算法是实现任务分配和资源管理的关键。

本文将介绍三种常见的调度算法:优先级调度、时间片轮转调度和抢占式调度。

一、优先级调度算法优先级调度算法是根据任务的优先级安排任务的执行顺序。

每个任务都有一个优先级值,数值越高表示优先级越高。

当一个任务就绪并等待执行时,调度器会选择优先级最高的任务来执行。

优先级调度算法可以保证高优先级任务及时得到执行,但可能会导致低优先级任务出现饥饿现象。

实际上,优先级调度算法可以分为静态优先级和动态优先级两种类型。

静态优先级是在任务创建时分配的,不会改变。

动态优先级根据任务的运行情况和系统状态进行动态调整,以提高系统的公平性和性能。

二、时间片轮转调度算法时间片轮转调度算法是一种周期性调度算法,每个任务被分配一个固定的时间片(时间段),当任务的时间片用完后,调度器会将任务挂起,并将CPU 分配给下一个任务执行。

当所有任务都执行完一次后,调度器会重新分配时间片,继续按照顺序执行任务。

时间片轮转调度算法可以保证任务的平均执行时间,并且避免了长时间任务的霸占资源问题。

然而,如果任务的时间片设置得过小,则会增加任务切换的开销。

如果任务的时间片设置得过大,则可能出现对实时任务响应时间的影响。

三、抢占式调度算法抢占式调度算法是一种灵活的调度策略,允许更高优先级的任务打断正在执行的低优先级任务,以确保高优先级任务的及时响应。

当一个任务就绪并具备运行条件时,调度器会立即安排其执行,无论当前是否有其他任务在执行。

抢占式调度算法可以有效地提高系统的响应速度和实时性,但可能会导致任务切换的频繁发生,增加了系统开销。

为了平衡性能和实时性的需求,抢占式调度算法通常会和其他调度策略结合使用,例如优先级和时间片轮转。

计算机系统中的调度算法

计算机系统中的调度算法

计算机系统中的调度算法在计算机系统中,调度算法是指运行多个进程或线程时,为了充分利用 CPU 资源,将进程或线程按照一定的规则分配 CPU 时间的算法。

调度算法的作用是在多个进程或线程之间,进行公平分配、高效利用 CPU 资源的策略。

针对不同的应用场景和实际需求,计算机系统中常见的调度算法主要有以下几种。

1.先来先服务 (First-Come First-Serve, FCFS)FCFS 调度算法是最早出现的一种调度算法,其核心思想是按照先来先到的顺序分配 CPU 时间片。

也就是说,先到达的进程先被分配 CPU 时间,后到达的进程则需要等待已经在执行的进程释放 CPU。

FCFS 调度算法的实现简单易懂,但是存在效率低下、无法应对高优先级和短进程等问题。

当进程的执行时间较长且无法预测时,FCFS 调度算法容易导致进程等待时间过长,从而降低系统的整体性能。

2.最短作业优先 (Shortest Job First, SJF)SJF 调度算法是一种基于进程执行时间的优先级调度算法。

其核心思想是按照进程执行时间的大小来进行排序,将执行时间最短的进程优先分配 CPU 时间。

SJF 调度算法可以提高系统的整体效率,减少进程等待时间和响应时间。

但是在实际应用中,由于难以预测每个进程的执行时间,SJF 调度算法常常会导致长作业得不到充分执行的情况。

3.优先级调度算法 (Priority Scheduling)优先级调度算法是一种基于进程优先级来进行调度的算法。

在该算法中,每个进程都被赋予一个优先级值,优先级高的进程先被分配 CPU 时间片。

在优先级调度算法中,高优先级进程的执行效率更高,但是可能会导致低优先级进程饥饿现象。

为了避免这种情况的发生,通常采用轮转时间片算法,将 CPU时间分配给每个进程的时间固定,使得每个进程都能得到充分执行的机会。

4.多级反馈队列调度算法 (Multi-level Feedback Queue Scheduling)多级反馈队列调度算法是一种综合了时间片轮转、优先级和抢占等多种特性的调度算法,通常由多个队列组成。

操作系统四种调度算法

操作系统四种调度算法

操作系统四种调度算法操作系统对进程的调度一般上有四种常见的算法。

下面由店铺为大家整理了操作系统的四种调度算法的相关知识,希望对大家有帮助!操作系统四重调度算法之一、先来先服务调度算法先来先服务(FCFS)调度算法是一种最简单的调度算法,该算法既可用于作业调度,也可用于进程调度。

当在作业调度中采用该算法时,每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业,将它们调入内存,为它们分配资源、创建进程,然后放入就绪队列。

在进程调度中采用FCFS算法时,则每次调度是从就绪队列中选择一个最先进入该队列的进程,为之分配处理机,使之投入运行。

该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。

操作系统四重调度算法之二、短作业(进程)优先调度算法短作业(进程)优先调度算法SJ(P)F,是指对短作业或短进程优先调度的算法。

它们可以分别用于作业调度和进程调度。

短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业,将它们调入内存运行。

而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程,将处理机分配给它,使它立即执行并一直执行到完成,或发生某事件而被阻塞放弃处理机时再重新调度。

操作系统四重调度算法之三、高优先权优先调度算法1.优先权调度算法的类型为了照顾紧迫型作业,使之在进入系统后便获得优先处理,引入了最高优先权优先(FPF)调度算法。

此算法常被用于批处理系统中,作为作业调度算法,也作为多种操作系统中的进程调度算法,还可用于实时系统中。

当把该算法用于作业调度时,系统将从后备队列中选择若干个优先权最高的作业装入内存。

当用于进程调度时,该算法是把处理机分配给就绪队列中优先权最高的进程,这时,又可进一步把该算法分成如下两种。

1) 非抢占式优先权算法在这种方式下,系统一旦把处理机分配给就绪队列中优先权最高的进程后,该进程便一直执行下去,直至完成;或因发生某事件使该进程放弃处理机时,系统方可再将处理机重新分配给另一优先权最高的进程。

处理机调度的常用算法

处理机调度的常用算法

处理机调度的常用算法包括以下几种:
1. 先来先服务调度算法(FCFS,First Come First Service):这是一种最简单的调度算法,按先后顺序进行调度。

既可用于作业调度,也可用于进程调度。

2. 短作业优先调度算法(SJF/SPF,Shortest Job First):该算法根据作业长短进行调度,有利于短作业(进程)的完成。

3. 高响应比优先调度算法(HRRN,Highest Response Raito Next):该算法综合考虑了作业长短和等待时间,能够适用于短作业较多的批处理系统中,但长作业的运行可能得不到保证。

4. 基于时间片的轮转调度算法(RR,Round Robin):该算法将系统中所有的就绪进程按照FCFS原则,排成一个队列。

每次调度时将CPU 分派给队首进程,让其执行一个时间片。

时间片的长度从几个ms到几百ms。

在一个时间片结束时,发生时钟中断。

调度程序据此暂停当前进程的执行,将其送到就绪队列的末尾,并通过上下文切换执行当前就绪的队首进程。

进程阻塞情况发生时,未用完时间片也要出让CPU。

这些算法各有优缺点,需要根据实际应用场景选择合适的算法。

几种操作系统调度算法

几种操作系统调度算法

几种操作系统调度算法操作系统调度算法是操作系统中用于确定进程执行的顺序和优先级的一种方法。

不同的调度算法有不同的优缺点,适用于不同的场景和需求。

下面将介绍几种常见的操作系统调度算法:1.先来先服务(FCFS)调度算法:先来先服务调度算法是最简单的调度算法之一、按照进程到达的顺序进行调度,首先到达的进程先执行,在CPU空闲时执行下一个进程。

这种算法实现简单,并且公平。

但是,由于没有考虑进程的执行时间,可能会导致长作业时间的进程占用CPU资源较长时间,从而影响其他进程的响应时间。

2.短作业优先(SJF)调度算法:短作业优先调度算法是根据进程的执行时间进行排序,并按照执行时间最短的进程优先执行。

这种算法可以减少平均等待时间,提高系统的吞吐量。

然而,对于长作业时间的进程来说,等待时间会相对较长。

3.优先级调度算法:优先级调度算法是根据每个进程的优先级来决定执行顺序的。

优先级可以由用户设置或者是根据进程的重要性、紧迫程度等因素自动确定。

具有较高优先级的进程将具有更高的执行优先级。

这种算法可以根据不同情况进行灵活调度,但是如果不恰当地设置优先级,可能会导致低优先级的进程长时间等待。

4.时间片轮转(RR)调度算法:时间片轮转调度算法将一个固定的时间片分配给每个进程,当一个进程的时间片用完时,将该进程挂起,调度下一个进程运行。

这种算法可以确保每个进程获得一定的CPU时间,提高系统的公平性和响应速度。

但是,对于长时间运行的进程来说,可能会引起频繁的上下文切换,导致额外的开销。

5.多级反馈队列(MFQ)调度算法:多级反馈队列调度算法将进程队列划分为多个优先级队列,每个队列有不同的时间片大小和优先级。

新到达的进程被插入到最高优先级队列,如果进程在时间片内没有完成,则被移到下一个较低优先级队列。

这种算法可以根据进程的执行表现自动调整优先级和时间片,更好地适应动态变化的环境。

以上是几种常见的操作系统调度算法,每种算法都有其优缺点和适用场景。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

2015年10月21日实验一 进程调度1.实验目的:通过对进程调度算法的模拟,进一步理解进程的基本概念,加深对进程运行状态和进程调度过程、调度算法的理解。

2.实验内容:(1)用C 语言(或其它语言,如Java )实现对N 个进程采用某种进程调度算法(如先来先服务调度、短作业优先调度、优先权调度、时间片轮转调度、多级反馈队列调度)的调度。

(2)为了清楚地观察每个进程的调度过程,程序应将每个进程的被调度情况显示出来。

(3)分析程序运行的结果,谈一下自己的收获。

3.设计实现: 1)流程图主流程图:choice!=1&&choice!=2c hoice==2c hoice==1YN开 始初始化参数 输入函数 输入chioce FCFS SJF输入有误,请重新输入!是否继续?结束输入函数流程图:请输入进程个数:NumNY i=0N i=0N先来先服务流程图:i=0NYNY开始Num>0&&Num<=100i <Num?输入进程 到达时间i++i <Num?输入进程 服务时间i++输入choice 选择算法结束开始 i <Num?进程到达?到达时间赋给NowTim服务时间赋给NowTim计算完成时间,周转时间(平均),带权周转时间(平均)输出结束短作业优先算法流程图:i =0Ni = 0开始计算第一次NowTime 和第一个进程的完成时间输出i <Num?进程到达?找出服务时间最短进计算完成时间,i++i <Num?计算(平均)周转时间 (平均)带权周转时间i++输出 结束2)详细设计本程序用C# 语言模拟了先来先服务,短作业优先两个调度算法,如下:环境:VS 2013using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading.Tasks;namespace sjf_01{class Program{const int Max = 100;int[] ArrivalTime = new int[Max];//到达时间int[] ServiceTime = new int[Max];//服务时间int[] FinishTime = new int[Max];//完成时间int[] WholeTime = new int[Max];//周转时间double[] WeightWholeTime = new double[Max];//帯权周转时间double AverageWT_FCFS, AverageWT_SJF; //平均周转时间double AverageWWT_FCFS, AverageWWT_SJF;//平均帯权周转时间int[] ServiceTime_SJF = new int[Max];//在SJF算法中使用到int Num = 0; int NowTime = 0;//记录当前时间double SumWT = 0, SumWWT = 0;//SumWT用来计算总的周转时间,SumWWT用来计算总的帯权周转时间int i;int choice;//记录选择void FCFS(){for (i = 0; i < Num; i++){if (ArrivalTime[i] > NowTime)//假如进程到达的时间比现在已经运行的时间NowTime大,说明在NowTime时刻进程未到达{NowTime = ArrivalTime[i];//把进程的到达时间赋给NowTime}NowTime += ServiceTime[i];//把进程的服务时间加到NowTime上FinishTime[i] = NowTime;//计算完成时间WholeTime[i] = FinishTime[i] - ArrivalTime[i];//计算周转时间=完成时间-到达时间WeightWholeTime[i] = (double)WholeTime[i] / ServiceTime[i];//计算带权周转时间=周转时间/服务时间SumWT += WholeTime[i];//计算总的周转时间SumWWT += WeightWholeTime[i];//计算总的帯权周转时间}AverageWT_FCFS = SumWT / Num;//平均周转时间AverageWWT_FCFS=SumWWT/Num;//平均帯权周转时间for (i = 0; i < Num; i++)//依次输出结果{//Console.WriteLine("时刻{0} 进程{1} 开始运行完成时间{2} 周转时间{3} 带权周转时间{4}",FinishTime[i]-ServiceTime[i],i+1,FinishTime[i],WholeTime[i],WeightWholeTime[i]);Console.Write("时刻:{0} ", FinishTime[i] - ServiceTime[i]);Console.Write("进程:{0} ", i+1);Console.Write("开始运行 ");Console.Write("完成时间:{0} ", FinishTime[i]);Console.Write("周转时间:{0} ", WholeTime[i]);Console.Write("带权周转时间:{0} ", WeightWholeTime[i]);Console.WriteLine();}Console.WriteLine("平均周转时间{0},平均带权周转时间{1}",AverageWT_FCFS,AverageWWT_FCFS );}void SJF(){int min = 0;NowTime = ArrivalTime[0] + ServiceTime[0];//计算第一次的NowTImeFinishTime[0] = NowTime;//计算第一个进程的完成时间ServiceTime_SJF[0] = 1000;//赋初值Console.Write("时刻{0} 进程{1} 开始运行", FinishTime[0] - ServiceTime[0],1);int allin = 0, j, k;for (i = 1; i < Num; i++)//进入循环,从第二个到达的进程开始{k = 1; min = 0;if (allin == 0){j = 0;while (ArrivalTime[j] <= NowTime && j < Num)//已经到达的进程{j++;if (j >= Num){allin = 1;}}}else{j = Num;}j = j - 1;//j是已经到达的进程数while (k <= j)//从已经到达的进程里找到服务时间最短的进程{if (ServiceTime_SJF[k] == 0)//进程的服务时间如果等于0,则跳过该进程k++;else{if (ServiceTime_SJF[min] > ServiceTime_SJF[k])//比较,找到服务时间最短的进程min = k;k++;}}ServiceTime_SJF[min] = 0;//找完后置零,便于下一次循环时使用NowTime += ServiceTime[min];//累加当前时间FinishTime[min] = NowTime;//完成时间}for (i = 0; i < Num; i++)//计算周转时间,带权周转时间,总的周转时间和总的带权周转时间{WholeTime[i] = FinishTime[i] - ArrivalTime[i];WeightWholeTime[i] = (double)WholeTime[i] / ServiceTime[i];SumWT += WholeTime[i];SumWWT += WeightWholeTime[i];}AverageWT_SJF = SumWT / Num;//平均周转时间AverageWWT_SJF = SumWWT / Num;//平均带权周转时间Console.WriteLine("完成时间:{0} 周转时间:{1} 带权周转时间:{2}",FinishTime[0],WholeTime[0],WeightWholeTime[0]);for (i = 1; i < Num; i++)//输出结果{Console.Write("时刻:{0} ", FinishTime[i] - ServiceTime[i]);Console.Write("进程:{0} ", i + 1);Console.Write("开始运行 ");Console.Write("完成时间:{0} ", FinishTime[i]);Console.Write("周转时间:{0} ", WholeTime[i]);Console.Write("带权周转时间:{0} ", WeightWholeTime[i]);Console.WriteLine();}Console.WriteLine("平均周转时间{0},平均带权周转时间{1}", AverageWT_SJF , AverageWWT_SJF );}void input(){Console.Write(" 请输入进程个数:");Num = Convert .ToInt32 (Console.ReadLine());while (Num > 100 || Num <= 0){Console.Write(" 进程数应在0--100之间,请正确输入!");Num = Convert.ToInt32(Console.ReadLine());}Console .WriteLine ("********************************************"); for (i = 0;i < Num ;i++){Console .Write (" 请输入第{0}个进程到达时间:",i+1);ArrivalTime [i] = Convert.ToInt32 (Console .ReadLine ());}Console .WriteLine ("********************************************"); for (i = 0;i < Num ;i++){int data = 0;Console .Write (" 请输入第{0}个进程服务时间:",i+1);data = Convert.ToInt32 (Console .ReadLine ());ServiceTime [i] = data ;ServiceTime_SJF [i] = data ;}Console.WriteLine("********************************************"); Console .Write ("请选择要使用的算法(1-FCFS,2-SJF):");choice = Convert.ToInt32 (Console .ReadLine ());}static void Main(string[] args){char flag = 'y';Program p = new Program();Loop:p.NowTime = 0;p.SumWT = 0;p.SumWWT = 0;//参数初始化p.input();//输入if (p.choice == 1)p.FCFS();//调用FCFS算法else if (p.choice == 2)p.SJF();//调用SJF算法else//输入有误,则重新选择{while (true ){Console.WriteLine("您的选择有误!请重新选择!");Console.Write("请选择要使用的算法(1-FCFS,2-SJF):");p.choice = Convert.ToInt32(Console.ReadLine());if (p.choice == 1){p.FCFS();break;}else if (p.choice == 2){p.SJF();break;}}}Console.WriteLine("是否继续使用该程序,按'y'或'Y'键继续,按其他任意键退出:"); flag = Convert .ToChar (Console .ReadLine ());if (flag == 'y' || flag == 'Y') goto Loop;Console.ReadKey();}}}4.实验结果FCFS:SJF:正常运行如上,其他情况:5.实验过程中出现的问题及解决办法在实现短作业方法过程中,由于没有事先判断其他进程是否需到达队列,直接执行短作业查找出现了问题,改善了程序,首先执行了服务到达的判断,在执行短作业查找,使得问题得到解决。

相关文档
最新文档