Linux的进程调度策略
理解Linux的进程调度和优先级
理解Linux的进程调度和优先级Linux是一种广泛使用的开源操作系统，它采用了多任务处理的方式，能够同时运行多个进程。
进程调度是Linux操作系统中非常重要的一部分，它决定了进程之间如何共享CPU资源，使得操作系统能够高效地运行。
进程调度是操作系统的核心功能之一，它负责按照一定的调度算法从就绪队列中选择一个进程并将其分配给CPU执行。
Linux操作系统采用了时间片轮转法作为默认的调度算法，即每个进程被分配一个时间片，当时间片用完之后，如果进程还未执行完毕，就会被挂起，将执行机会分配给下一个就绪进程。
这样可以保证多个进程之间的平等性，防止某个进程长时间占用CPU资源。
除了时间片轮转法，Linux操作系统还支持其他的调度算法，如优先级调度、实时调度等。
优先级调度是一种根据进程的优先级来进行调度的方法，优先级高的进程会优先获得CPU执行权。
在Linux中，每个进程都有一个静态优先级和一个动态优先级，静态优先级由进程创建时指定，而动态优先级会根据进程执行情况进行动态调整。
实时调度是一种对实时任务进行优先调度的方法，可以保证实时任务的响应时间。
Linux操作系统中，进程的优先级范围是-20到19，数值越小表示优先级越高。
根据进程的优先级，Linux操作系统按照先运行高优先级进程的原则来进行调度。
当有多个具有相同优先级的进程时，Linux会采用时间片轮转法来进行调度。
通过灵活调整进程的优先级，可以合理分配CPU资源，提高系统的整体性能和响应速度。
除了优先级调度算法外，Linux操作系统还支持实时调度算法。
实时任务对响应时间要求非常高，需要保证任务在规定的时间内完成。
为了实现实时调度，Linux操作系统引入了实时进程和实时调度策略。
实时进程是一类对时间敏感的进程，它们可以获得更高的执行优先级和更快的响应时间。
实时进程的调度策略有FIFO（先进先出）调度、循环调度等。
理解Linux的进程调度和优先级对于系统管理员和开发人员来说非常重要。
请描述linux下常见的调度策略及调度原理
请描述linux下常见的调度策略及调度原理在Linux下，常见的进程调度策略包括：1.CFS（Completely Fair Scheduler）完全公平调度器：CFS是Linux内核默认的调度策略。
它通过使用红黑树数据结构来维护进程队列，以确保公平分配CPU时间片。
CFS基于进程的虚拟运行时间（vruntime）进行调度，根据进程的优先级和历史执行情况来分配CPU时间。
2.实时调度策略：Linux提供了多种实时调度策略，包括先来先服务（FIFO）和轮转（Round Robin）调度策略。
实时任务具有较高的优先级，可以实时响应系统事件，适用于对时间敏感的应用，如嵌入式系统和实时视频处理等。
3.基于优先级的调度策略：Linux还支持基于静态优先级和动态优先级的调度策略。
这些策略根据进程的优先级决定调度顺序，优先级较高的进程将获得更多的CPU时间。
调度原理是指操作系统如何决定哪个进程获得CPU资源的分配。
Linux的调度器使用时间片轮转和优先级调度等策略来实现公平和高效的调度。
调度器会根据不同的调度策略和优先级，分配给每个进程一定的CPU时间片。
时间片指定了进程能够运行的时间段。
当一个进程的时间片用完或发生了阻塞事件时，调度器会将CPU 分配给下一个就绪状态的进程。
CFS调度器基于虚拟运行时间（vruntime）来分配CPU时间。
vruntime表示进程所需的实际运行时间，CFS通过比较进程的vruntime来决定下一个运行的进程。
较长时间没有运行的进程会被赋予更长的时间片，以实现公平调度。
实时调度策略将优先级更高的实时任务放在优先级队列的前面，以确保它们及时地响应系统事件。
在实时任务运行期间，其他普通优先级的任务将被暂时挂起。
总的来说，Linux的调度器通过多种调度策略和优先级，根据不同类型的任务和进程的要求，合理分配CPU资源，以实现公平、高效和响应及时的调度。
这样可以确保系统的正常运转并提高性能。
Linux命令行中的进程优先级和调度策略技巧
Linux命令行中的进程优先级和调度策略技巧Linux操作系统以其稳定性和自定义性而闻名，它提供了强大的命令行工具，使用户能够更好地管理系统资源和进程。
进程优先级和调度策略是Linux命令行下的重要主题之一，它们决定了系统资源的分配和进程执行的顺序。
本文将介绍Linux命令行中的进程优先级和调度策略技巧，旨在帮助读者更好地理解和运用这些概念。
一、进程优先级在Linux中，每个进程都有一个与之相关的优先级。
优先级决定了进程在竞争系统资源时的顺序和权重。
Linux中的进程优先级范围从-20到+19，其中-20表示最高优先级，+19表示最低优先级。
默认情况下，大多数进程的优先级为0。
通过`nice`命令，我们可以更改进程的优先级。
该命令接受一个整数参数，范围为-20到+19，负数值表示更高的优先级，正数值表示更低的优先级。
以下是一个更改进程优先级的示例：```$ nice -n -5 command```这个命令将以较高的优先级运行名为`command`的进程。
另外一个与进程优先级相关的概念是实时进程。
实时进程具有较高的优先级，用于处理与时间敏感性有关的任务。
通过`chrt`命令，我们可以将进程设置为实时进程。
例如，下面的命令将将进程设置为实时进程，并将其优先级设置为99：```$ chrt -r 99 command```二、进程调度策略进程调度策略决定了系统如何分配CPU时间片给各个进程。
Linux 中有三种主要的进程调度策略：1. 轮转调度（Round Robin Scheduling）：轮转调度是Linux默认的调度策略，通过在所有可运行的进程之间循环分配CPU时间片，以确保公平共享CPU资源。
这种策略适用于多任务场景，并确保每个进程都有机会执行。
2. 先进先出调度（First Come First Serve Scheduling）：FCFS调度策略按照进程到达的先后顺序为其分配CPU时间片。
linux下常见的调度策略及调度原理
linux下常见的调度策略及调度原理Linux是一种开源的操作系统，广泛应用于服务器和嵌入式设备中。
在Linux系统中，进程调度策略是操作系统的核心组成部分之一，它决定了进程的执行顺序和时间分配。
本文将介绍Linux下常见的调度策略及其调度原理。
在Linux系统中，常见的进程调度策略包括先来先服务（FCFS）、最短作业优先（SJF）、时间片轮转（RR）和优先级调度（Priority Scheduling）等。
先来先服务（FCFS）是一种简单而直观的调度策略，它按照进程到达的先后顺序进行调度。
即当一个进程到达系统时，它将被放入就绪队列的末尾，并等待CPU的分配。
当CPU空闲时，系统将选择就绪队列中的第一个进程分配给CPU执行。
这种调度策略的优点是公平性强，但缺点是无法处理长作业和短作业的差异，容易产生"饥饿"现象。
最短作业优先（SJF）调度策略是根据进程的执行时间来决定优先级的调度策略。
即系统会选择执行时间最短的进程先执行，以减少平均等待时间。
这种调度策略的优点是能够最大程度地减少平均等待时间，但缺点是可能会出现长作业等待时间过长的问题。
时间片轮转（RR）是一种基于时间片的调度策略，每个进程被分配一个固定长度的时间片。
当一个进程的时间片用完时，系统将把CPU分配给下一个进程。
这种调度策略的优点是能够有效地平衡进程之间的响应时间，但缺点是可能会导致频繁的上下文切换。
优先级调度（Priority Scheduling）是一种根据进程优先级来决定调度顺序的策略。
每个进程被分配一个优先级，优先级越高的进程越容易被调度执行。
这种调度策略的优点是能够根据不同进程的需求进行灵活调度，但缺点是可能会导致低优先级进程的"饥饿"问题。
在Linux系统中，调度算法的实现是通过内核的进程调度器来完成的。
内核中的调度器会根据不同的调度策略来选择下一个要执行的进程，并将其上下文切换到CPU中执行。
Linux操作系统的进程调度机制
Linux操作系统的进程调度机制进程调度是操作系统中重要的一项功能，它决定了在多个进程同时运行时的优先级和时间分配。
Linux操作系统采用了多种进程调度算法，包括时间片轮转调度算法、优先级调度算法和反馈调度算法，以满足不同应用场景下的需求。
一、时间片轮转调度算法时间片轮转调度算法是Linux操作系统中最常用的调度算法之一。
它将CPU时间分为一个个时间片，每个进程在一个时间片内运行，当时间片用完后，进程被暂停，CPU切换到下一个进程。
这种调度算法公平而高效，保证了各个进程都能有公平的运行时间。
二、优先级调度算法优先级调度算法是基于进程优先级的调度方法。
Linux操作系统中每个进程都有一个优先级，优先级高的进程会被优先调度执行，而优先级低的进程会被暂时延迟。
优先级调度算法可以确保重要任务的及时执行，但也可能导致低优先级进程长时间得不到执行，产生“饥饿”现象。
三、反馈调度算法反馈调度算法是一种基于进程历史行为的动态调度算法。
Linux操作系统中的反馈调度算法将进程分为多个优先级队列，新创建的进程首先进入最高优先级队列，如果某个进程的执行时间超过了一个时间限制，该进程会被降低优先级，放入下一个较低的队列中执行。
这种调度算法可以灵活地根据进程的实际运行情况进行调整，以提高系统的整体效率。
总结：Linux操作系统采用了时间片轮转调度算法、优先级调度算法和反馈调度算法等多种进程调度算法，以满足不同应用场景下的需求。
时间片轮转调度算法保证了各个进程都能有公平的运行时间；优先级调度算法可以确保重要任务的及时执行；反馈调度算法根据进程的实际运行情况进行调整，提高了系统的整体效率。
这些调度算法共同协作，保障了Linux操作系统的稳定性和性能。
linux内核进程cpu调度基本原理
linux内核进程cpu调度基本原理Linux内核的CPU调度基本原理是通过多任务处理，将CPU 时间片分配给不同的进程或线程来实现。
1. 调度策略：Linux内核支持多种调度策略，包括先来先服务（FCFS）、时间片轮转、优先级调度等。
默认的调度策略是时间片轮转调度策略，即每个进程被分配一个时间片，在时间片用完之后，将CPU切换到下一个就绪状态的进程上。
2. 就绪队列：内核会维护一个就绪队列，存放所有准备好运行但还未分配CPU时间的进程。
根据进程的优先级和调度策略，内核会从就绪队列中选择一个合适的进程来执行。
3. 进程优先级：每个进程都有一个优先级值，表示其重要性和紧急程度。
较高优先级的进程在调度时会获得更多的CPU时间。
Linux内核使用动态优先级调度策略，根据进程的历史行为和资源使用情况动态调整进程的优先级。
4. 时间片和抢占：时间片是CPU分配给进程的最小单位，当一个进程的时间片用完后，如果它还未完成，内核会将其置于就绪队列末尾，并将CPU分配给下一个就绪进程。
此外，Linux 内核支持抢占式调度，即当一个优先级更高的进程出现时，可立
即抢占当前运行的进程，将CPU资源分配给新的进程。
5. 实时进程：除了普通进程，Linux内核还支持实时进程。
实时进程具有更高的优先级和较小的延迟要求，它们得到更快的响应时间。
实时进程的调度算法相对于普通进程更加严格，以满足实时性要求。
Linux内核的CPU调度基本原理是通过就绪队列、进程优先级和时间片轮转等策略，将CPU时间动态地分配给不同的进程或线程，以完成多任务处理。
linux进程调度的方法
linux进程调度的方法Linux进程调度是操作系统中的重要功能之一，它负责决定在多个进程之间如何分配CPU时间片。
进程调度算法的选择对系统的性能和响应时间有着重要的影响。
本文将介绍几种常见的Linux进程调度方法。
1. 先来先服务（First-Come, First-Served，FCFS）FCFS是最简单的调度算法，按照进程到达的先后顺序进行调度。
当一个进程执行完毕后，下一个进程将被调度执行。
这种方法简单直观，但存在"饥饿"问题，即长时间等待的进程可能得不到执行。
2. 最短作业优先（Shortest Job First，SJF）SJF调度算法根据进程的执行时间长度来进行调度，执行时间越短的进程优先执行。
这种算法可以减少平均等待时间，但需要预知每个进程的执行时间，实际中很难实现。
3. 优先级调度（Priority Scheduling）优先级调度算法根据进程的优先级来进行调度，优先级较高的进程先执行。
可以通过静态优先级或动态优先级来实现。
静态优先级在进程创建时确定，而动态优先级在运行时根据进程的行为进行调整。
优先级调度可以根据系统需求进行灵活调整，但可能存在优先级反转的问题。
4. 时间片轮转（Round Robin，RR）时间片轮转是一种基于时间片的调度算法。
每个进程被分配一个固定长度的时间片，在该时间片内执行，时间片用完后，进程被挂起，等待下一次调度。
时间片轮转可以保证公平性，但可能存在上下文切换开销较大的问题。
5. 多级反馈队列（Multilevel Feedback Queue，MLFQ）多级反馈队列是一种综合性的调度算法。
系统维护多个就绪队列，每个队列具有不同的优先级。
新到达的进程首先进入最高优先级队列，当队列中没有可执行进程时，低优先级队列的进程才能执行。
如果一个进程在一个队列中执行的时间过长，系统会将其移动到一个更低优先级的队列中，以避免长时间运行的进程占用CPU。
深入理解Linux内核－进程调度
深⼊理解Linux内核－进程调度1、什么时候进⾏进程切换调度策略⽬标：1、进程响应尽量快；2、后台作业吞吐量尽量⾼；3、尽可能避免进程饥饿；4、低优先级和⾼优先级进程需要尽量调和。
调度策略：决定什么时候选择什么进程运⾏的规则。
基于分时技术。
调度程序跟踪进程，动态调整优先级进程分三类：1、交互进程；2、批处理进程；3、实时进程；抢占⽆需等待当前进程的时间⽚⽚结束时间⽚：应该⼤于进程切换花费的时间，越⼤，CPU利⽤率越⾼。
但是太⼤⼜会导致进程看起来不是并发的。
进程动态优先级：进程的动态优先级，是在静态优先级的基础上，根据它的平均睡眠时间，调整它的优先级，睡眠时间长，提⾼它的优先级；反之，降低优先级公式动态优先级＝ max（100， min(静态优先级－ bonus ＋5， 139) 其中bonus 与平均睡眠时间成正⽐，范围是0～10。
活动进程：没有⽤完时间⽚的进程，运⾏运⾏过期进程：⽤完了时间⽚的进程，被禁⽌运⾏，直到所有的活动进程都过期另外：活动的批处理进程总是会变为过期进程，活动的交互进程通常仍然是活动进程，它会被调度程序重新填充时间⽚。
实时进程：与实时优先级相关（1～99），实时进程总是活动进程两种创建新进程的⽅式：1、fork：创建当前进程的副本；2、exec：将新进程加载到当前进程的内存中执⾏。
内核⽀持的程序执⾏形式：1、Unix进程，也叫做重量级进程；本质上进程可以由N个线程组成，这些线程共享数据和资源。
2、线程，也叫做轻量级进程命名空间：1、包含N个PID的集合进程地址空间：1、每个进程使⽤独⽴的虚拟地址空间2、虚拟地址空间都是⼀样都⼤⼩，不考虑可⽤物理内存的⼤⼩3、使⽤页表为物理地址分配虚拟地址4、两个进程的虚拟地址页可以映射到同⼀个物理地址页帧，即共享内存页：虚拟地址空间中的页页帧：物理内存页页表：将虚拟地址空间映射到物理地址空间的数据结构。
3linux进程调度方法
linux进程调度方法linux内核的三种调度方法：1，SCHED_OTHER 分时调度策略， 2，SCHED_FIFO实时调度策略，先到先服务 3，SCHED_RR实时调度策略，时间片轮转实时进程将得到优先调用，实时进程根据实时优先级决定调度权值，分时进程则通过nice和counter值决定权值，nice越小，counter越大，被调度的概率越大，也就是曾经使用了cpu最少的进程将会得到优先调度。
SHCED_RR和SCHED_FIFO的不同：当采用SHCED_RR策略的进程的时间片用完，系统将重新分配时间片，并置于就绪队列尾。
放在队列尾保证了所有具有相同优先级的RR任务的调度公平。
SCHED_FIFO一旦占用cpu则一直运行。
一直运行直到有更高优先级任务到达或自己放弃。
如果有相同优先级的实时进程（根据优先级计算的调度权值是一样的）已经准备好，FIFO时必须等待该进程主动放弃后才可以运行这个优先级相同的任务。
而RR可以让每个任务都执行一段时间。
相同点： RR和FIFO都只用于实时任务。
创建时优先级大于0(1-99)。
按照可抢占优先级调度算法进行。
就绪态的实时任务立即抢占非实时任务。
所有任务都采用linux分时调度策略时。
1，创建任务指定采用分时调度策略，并指定优先级nice值(-20~19)。
2，将根据每个任务的nice值确定在cpu上的执行时间(counter)。
3，如果没有等待资源，则将该任务加入到就绪队列中。
4，调度程序遍历就绪队列中的任务，通过对每个任务动态优先级的计算(counter+20-nice)结果，选择计算结果最大的一个去运行，当这个时间片用完后(counter减至0)或者主动放弃cpu时，该任务将被放在就绪队列末尾(时间片用完)或等待队列(因等待资源而放弃cpu)中。
5，此时调度程序重复上面计算过程，转到第4步。
6，当调度程序发现所有就绪任务计算所得的权值都为不大于0时，重复第2步。
Linux的进程调度
Linux的进程调度传统Unix 操作系统的调度算法必须实现几个互相冲突的目标：进程响应时间尽可能快，后台作业的吞吐量尽可能高，进程的饥饿现象尽可能避免，低优先级和高优先级进程的需要尽可能调和等等。
决定什么时候以怎样的方式选择一个新进程运行的这组规则就是所谓的调度策略（scheduling policy ）。
Linux的进程调度是基于分时技术（time-sharing ）。
允许多个进程“并发”运行就意味着CPU的时间被粗略地分成“片”，给每个可运行进程分配一片。
当然，单处理器在任何给定的时刻只能运行一个进程。
当一个并发执行的进程其时间片或时限（quantum ）到期时还没有终止，进程切换就可以发生。
分时依赖于定时中断，因此，对进程是透明的。
为保证CPU分时，不需要在程序中插入额外的代码。
调度策略也是基于依照优先级排队的进程。
有时用复杂的算法求出进程当前的优先级，但最后的结果是相同的：每个进程都与一个值相关联，这个值表示把进程如何适当地分配给CPU 。
在Linux中，进程的优先级是动态的。
调度程序跟踪进程做了些什么，并周期性地调整它们的优先级。
在这种方式下，在较长的时间间隔内没有使用CPU 的进程，通过动态地增加它们的优先级来提升它们。
相应地，对于已经在CPU 上运行了较长时间的进程，通过减少它们的优先级来处罚它们。
每个进程在创建之初有一个基本的优先级，执行期间调度系统会动态调整它的优先级，交互性高的任务会获得一个高的动态优先级，而交互性低的任务获得一个低的动态优先级。
类进程的时间片计算如下图所示：当谈及有关调度问题时，传统上把进程分类为“I/O范围（I/O-bound ）”或“CPU范围（CPU-bound ）”。
前者频繁地使用I/O设备，并花费很多时间等待I/O 操作的完成；而后者是需要大量CPU时间的数值计算应用程序。
Linux 操作系统支持多进程，进程控制块PCB(Process Control Block) 是系统中最为重要的数据结构之一。
Linux命令行中的进程调度和优先级设置技巧
Linux命令行中的进程调度和优先级设置技巧一、引言在Linux系统中，进程调度和优先级设置是提高系统性能和资源管理的重要手段。
通过合理分配进程的CPU时间片和优先级，可以有效提高系统的响应速度和资源利用率。
本文将介绍Linux命令行中的进程调度和优先级设置技巧。
二、进程调度技巧1. 查看进程列表通过使用ps命令，可以查看系统中运行的所有进程及其状态。
例如，输入以下命令：```ps -ef```该命令将列出所有进程的详细信息，包括进程ID、父进程ID、状态等。
2. 杀死进程如果某个进程出现问题或者需要终止运行，可以使用kill命令进行进程终止。
例如，输入以下命令：```kill 进程ID```其中，进程ID为需要终止的进程的标识符。
3. 修改进程优先级在Linux中，可以使用nice命令或renice命令来调整进程的优先级。
优先级范围从-20到19，-20表示最高优先级，19表示最低优先级。
- 使用nice命令nice命令可以在启动新进程时设置其优先级。
例如，输入以下命令：```nice -n 10 command```其中，-n 10表示设置新进程的优先级为10。
- 使用renice命令renice命令可以修改已经运行的进程的优先级。
例如，输入以下命令：```renice 10 进程ID```该命令将进程ID为进程ID的进程的优先级设置为10。
4. 实时进程调度Linux系统支持实时进程调度，可以通过使用chrt命令设置进程为实时进程。
例如，输入以下命令：```chrt -r 99 command```该命令将启动一个实时进程，并将其优先级设置为99。
三、进程优先级设置技巧1. 进程优先级调整原则在进行进程优先级设置时，需要遵循以下原则：- 重要性高的进程应该具有较高的优先级，以确保系统服务的响应速度。
- CPU密集型进程可以设置较低的优先级，以充分利用CPU资源。
- I/O密集型进程可以设置较高的优先级，以提高IO操作的效率。
浅析Linux进程调度策略
近年来 ． Ｌ ｉ ｎ ｕ ｘ系统在嵌入式领域得到 了广泛的应用 ． 为 了满足嵌 入式系统 的实时 ｌ 生 需求往往需要对 内核进行改造 ． 许 多改造实例是从 修改调度程序人手的 因此 ．充分 了解 Ｌ ｉ ｎ ｕ ｘ 进程调度 的原 理和策 略 ．将有利 于我们更加深入理解计 算机操作 系统 中多进程调度 的原 理． 为实时操作系统的开发 ， 特别是嵌入式系统的开发提供 理论指导 。 １ ． 调 度 时 机 主要发生在系统从 内核态返 回到用户态时 ｆ 即从 系统空 间返 回到 用户空 间） ， 主要发生以下几种情况 ： 用 户进程进行 系统调用 返 回时 （ 系统调 用在 系统空 间中完成 ） 。 中处理完 成时 （ 中断处 理也 是在 系统空 间 ） ： 异 常处理完 成 时 （ 异 常 处 理也在系统 空间） 。Ｃ Ｐ Ｕ每次从系统空 间返 回到用户空 间时 ． 都 会 进行一次进程调度 。 此外 ， 每次时钟中断产 生时． 发现 当前运行进程的 时间片超 时 ． 也会 进行一次进程调度（ 这也是 Ｌ Ｉ Ｎ Ｕ Ｘ系统中各个进程 都 能够得 到执行 的原 因， 否则 ， 如果某个进程 不进行 系统调用 ， 自身运 行有 没有异常 ， 又不 自愿放弃 Ｃ Ｐ Ｕ． 系统 中又没有中断 ． 则该进程会一 直等到 时间片用完为止 ） 也就是说 ．强制进程 调度 只发生在用户空 间． 绝 对不会发生在 系统空间中 ２ ． 调 度 方 式 通过以上调度时机的分析 ． 可见 ． Ｌ Ｉ Ｎ Ｕ Ｘ内核使用的是“ 有 条件可 剥夺 ” 方式 的进 程调度 ． 当系统运行 在系统空 间时 ． 是 不可 已被剥夺 的． 但是 ， 一旦系统从 系统空 间返 回返 回到用户空间时 ． 当前进程就有 可能被剥夺 Ｃ Ｐ Ｕ的占用权
解析Linux系统中的进程调度范本1份
解析Linux系统中的进程调度范本1份解析Linux系统中的进程调度 1解析Linux系统中的进程调度操作系统要实现多进程，进程调度必不可少。
有人说，进程调度是操作系统中最为重要的一个部分。
我觉得这种说法说得太绝对了一点，就像很多人动辄就说“某某函数比某某函数效率高__倍"一样，脱离了实际环境，这些结论是比较片面的。
而进程调度究竟有多重要呢？首先，我们需要明确一点：进程调度是对TASK___状态的进程进行调度（参见《linux进程状态浅析》）。
如果进程不可执行（正在睡眠或其他），那么它跟进程调度没多大关系。
所以，如果你的系统负载非常低，盼星星盼月亮才出现一个可执行状态的进程。
那么进程调度也就不会太重要。
哪个进程可执行，就让它执行去，没有什么需要多考虑的。
反之，如果系统负载非常高，时时刻刻都有N多个进程处于可执行状态，等待被调度运行。
那么进程调度程序为了协调这N个进程的执行，必定得做很多工作。
协调得不好，系统的性能就会大打折扣。
这个时候，进程调度就是非常重要的。
尽管我们平常接触的很多计算机（如桌面系统、网络服务器、等）负载都比较低，但是linux作为一个通用操作系统，不能假设系统负载低，必须为应付高负载下的进程调度做精心的设计。
当然，这些设计对于低负载（且没有什么实时性要求）的环境，没多大用。
极端情况下，如果CPU的负载始终保持0或1（永远都只有一个进程或没有进程需要在CPU上运行），那么这些设计基本上都是徒劳的。
优先级现在的操作系统为了协调多个进程的“同时”运行，最基本的手段就是给进程定义优先级。
定义了进程的优先级，如果有多个进程同时处于可执行状态，那么谁优先级高谁就去执行，没有什么好纠结的了。
那么，进程的优先级该如何确定呢？有两种方式：由用户程序指定、由内核的调度程序动态调整。
（下面会说到）linux内核将进程分成两个级别：普通进程和实时进程。
实时进程的优先级都高于普通进程，除此之外，它们的调度策略也有所不同。
Linux内核的三种调度策略
Linux内核的三种调度策略：1，SCHED_OTHER 分时调度策略，2，SCHED_FIFO实时调度策略，先到先服务。
一旦占用cpu则一直运行。
一直运行直到有更高优先级任务到达或自己放弃3，SCHED_RR实时调度策略，时间片轮转。
当进程的时间片用完，系统将重新分配时间片，并置于就绪队列尾。
放在队列尾保证了所有具有相同优先级的RR任务的调度公平Linux线程优先级设置首先，可以通过以下两个函数来获得线程可以设置的最高和最低优先级，函数中的策略即上述三种策略的宏定义：int sched_get_priority_max(int policy);int sched_get_priority_min(int policy);SCHED_OTHER是不支持优先级使用的，而SCHED_FIFO和SCHED_RR支持优先级的使用，他们分别为1和99，数值越大优先级越高。
设置和获取优先级通过以下两个函数int pthread_attr_setschedparam(pthread_attr_t*attr,const struct sched_param *param);int pthread_attr_getschedparam(const pthread_attr_t*attr,struct sched_param *param); param.sched_priority = 51;//设置优先级系统创建线程时，默认的线程是SCHED_OTHER。
所以如果我们要改变线程的调度策略的话，可以通过下面的这个函数实现。
int pthread_attr_setschedpolicy(pthread_attr_t*attr,int policy);上面的param使用了下面的这个数据结构：struct sched_param{int __sched_priority;//所要设定的线程优先级};我们可以通过下面的测试程序来说明，我们自己使用的系统的支持的优先级：#include<stdio.h>#include<pthread.h>#include<sched.h>#include<assert.h>static int get_thread_policy(pthread_attr_t*attr){int policy;int rs =pthread_attr_getschedpolicy(attr,&policy);assert(rs==0);switch(policy){case SCHED_FIFO:printf("policy= SCHED_FIFO\n");break;case SCHED_RR:printf("policy= SCHED_RR");break;case SCHED_OTHER:printf("policy=SCHED_OTHER\n");break;default:printf("policy=UNKNOWN\n");break;}return policy;}static void show_thread_priority(pthread_attr_t*attr,int policy) {int priority = sched_get_priority_max(policy);assert(priority!=-1);printf("max_priority=%d\n",priority);priority= sched_get_priority_min(policy);assert(priority!=-1);printf("min_priority=%d\n",priority);}static int get_thread_priority(pthread_attr_t*attr){struct sched_param param;int rs =pthread_attr_getschedparam(attr,¶m); assert(rs==0);printf("priority=%d",param.__sched_priority);return param.__sched_priority;}static void set_thread_policy(pthread_attr_t*attr,int policy) {int rs =pthread_attr_setschedpolicy(attr,policy);assert(rs==0);get_thread_policy(attr);}int main(void){pthread_attr_t attr;struct sched_param sched;int rs;rs =pthread_attr_init(&attr);assert(rs==0);int policy = get_thread_policy(&attr);printf("Show current configuration of priority\n");show_thread_priority(&attr,policy);printf("show SCHED_FIFO of priority\n"); show_thread_priority(&attr,SCHED_FIFO);printf("show SCHED_RR of priority\n");show_thread_priority(&attr,SCHED_RR);printf("show priority of current thread\n");int priority = get_thread_priority(&attr);printf("Set thread policy\n");printf("set SCHED_FIFO policy\n");set_thread_policy(&attr,SCHED_FIFO);printf("set SCHED_RR policy\n");set_thread_policy(&attr,SCHED_RR);printf("Restore current policy\n");set_thread_policy(&attr,policy);rs =pthread_attr_destroy(&attr);assert(rs==0);return 0;}下面是测试程序的运行结果：policy=SCHED_OTHERShow current configuration of prioritymax_priority=0min_priority=0show SCHED_FIFO of prioritymax_priority=99min_priority=1show SCHED_RR of prioritymax_priority=99min_priority=1show priority of current threadpriority=0Set thread policyset SCHED_FIFO policypolicy= SCHED_FIFOset SCHED_RR policypolicy= SCHED_RRRestore current policypolicy=SCHED_OTHERLinux线程调度策略与优先级（二）上一篇文章介绍了Linux下的调度策略和优先级，在Ubuntu09.10上的一些特性，这里测试一下其中的两种特性，SCHED_OTHER和SCHED_RR，还有就是优先级的问题，是不是能够保证，高优先级的线程，就可以保证先运行。
请描述linux下常见的调度策略及调度原理。
请描述linux下常见的调度策略及调度原理。
Linux下常见的调度策略有：完全公平调度（CFS）、实时调度（RT）、多级反馈队列调度（MFQ）、最短任务优先（SJF）等。
1. 完全公平调度（CFS）：CFS是Linux内核默认的调度策略，它基于红黑树数据结构来表示任务的优先级队列。
每个任务都有自己的虚拟运行时间（vruntime），调度器会根据任务的虚拟运行时间来决定下一个执行的任务。
CFS调度策略的目标是在尽量公平地分配系统资源的同时，保证任务执行的效率。
2. 实时调度（RT）：实时调度分为实时先进先出调度（FIFO）和实时轮转调度（RR）两种。
实时调度策略主要针对实时任务，确保其能够在预定的时间内得到执行，并且具有可预测性。
3. 多级反馈队列调度（MFQ）：多级反馈队列调度策略将进程划分为多个优先级队列，每个队列具有不同的时间片大小。
当一个任务的时间片用完后，会被降级到下一个更低优先级队列中，从而避免了饥饿问题。
4. 最短任务优先（SJF）：最短任务优先调度策略会根据任务的估计运行时间进行排序，选择估计运行时间最短的任务优先执行。
这种调度策略可以最大限度地减少平均等待时间和响应时间。
调度原理：Linux调度策略的原理是根据任务的优先级和一定的规则来决定下一个要执行的任务。
调度器会根据任务的类型、优先级、运行时间等因素来分配CPU资源，并保证不同类型的任务得到合理的调度。
调度器还会考虑任务的公平性，尽量均衡地分配CPU时间片，防止某些任务占用过多的资源。
调度器还会根据实时任务的时间限制要求，确保它们能够按时得到执行。
各种不同的调度算法和策略都是为了实现这些原则和目标。
第3章Linux进程调度(2)
Schedule()函数
Linux调度时机
• 进程状态转换的时刻：进程终止、进程 睡眠； • 就绪队列中新增加一个进程时； • 当前进程的时间片用完时 • 进程从系统调用返回到用户态时； • 内核处理完中断后，进程返回到用户态 时；
Linux的调度策略
• 时间片轮转（Round Robing) • 同时又保证高优先级的进程运行得既快， 时间又长。 • 还实现了二级优先级队列：一个标准队 列和一个实时(real time)队列。
衡量进程可调度的程度
static inline int goodness(struct task_struct * p, struct task_struct * prev) { int weight; // 权值，作为衡量进程是否运行的唯一依据 switch(p->policy) { // 实时进程 case SCHED_FIFO: case SCHED_RR: weight = 1000 + p->rt_priority; // 普通进程 case SCHED_OTHER: weight = p->counter; // 做细微的调整 if (weight) { if (p == prev) weight = weight+1; } } return weight; //返回权值作为进程调度的唯一依据，谁的权值大，就 调度谁运行 }
实时进程的调度
• 采用两种调度策略，即FIFO和RR。 • 实时进程的counter只表示该进程的剩余 时间片。并不作为衡量它是否运行的标 准。 • 实时进程的两个优先级用来衡量实时进 程是否值得运行。
就绪队列
• 调度程序直接操作的对象就是就绪队列 • 队列的标志：idle_Hale Waihona Puke ask和队列的长度。课后题
Linux内核的进程调度策略和内存管理
Linux内核的进程调度策略和内存管理摘要:内存是Linux内核所管理的最重要的资源之一，内存管理系统是操作系统中最为重要的部分。
对于Linux的初学者来说，熟悉Linux的内存管理非常重要。
进程是运行于虚拟地址空间的一个程序。
可以说，任何在Linux系统下运行的程序都是进程。
Linux系统中包括交互进程和批处理进程。
交互进程是由Shell控制和运行的，既可以在前台运行，也可以在后台运行。
批处理进程不属于某个终端，被提交到一个队列中以便顺序执行。
大多数的进程都需要虚拟内存。
Linux进程中最知名的属性就是它的进程号（Process Identity Number，PID）以其父进程号（Parent Process ID，PPID）。
PID、PPID都是非零正整数。
一个PID唯一地标识一个进程。
一个进程创建新进程称为创建了子进程（Child Process），创建子进程的进程称为父进程。
所有进程追溯其祖先最终都会落到进程号为1的进程身上，这个进程叫做init进程，是内核自举后第一个启动的进程。
Init进程的作用是扮演终结父进程的角色。
因为init进程永远不会被终止，所以系统总是确信它的存在，并在必要时以它为参照。
如果某个进程在它衍生出来的全部子进程结束之前被终止，就会出现必须以init为参照的情况。
此时那些失去了父进程的子进程就都会以init作为其父进程。
通过执行ps-af命令，可以列出许多父进程ID为1的进程。
Linux提供了一条pstree命令，允许用户查看系统内正在运行的各个进程之间的继承关系。
直接在命令行输入pstree，程序会以树状结构方式列出系统中正在运行的各进程之间的继承关系。
关键词:linux; 进程调度；调度策略；内存管理Linux kernel process scheduling and memory management Abstract:Linux kernel memory is managed by one of the most important resources, memory management system is the most important part of the operating system. For Linux beginners to be familiar with Linux's memory management is very important.Linux kernel memory is managed by one of the most important resources, memory management system is the most important part of the operating system. For Linux beginners to be familiar with Linux is memory management is very important.Process is running on a virtual address space of a program. Can be said that any program running under Linux system is the process. Linux system, including the interactive process and the batch process. Interactive process is controlled and run by the Shell, both running in the foreground, you can also run in the background. Batch process does not belong to a terminal, to be submitted to a queue for order execution. Most of the process requires virtual memory bstract .Linux is best-known properties of the process is its process ID (Process Identity Number, PID) to the parent process ID (Parent Process ID, PPID). PID, PPID is non-zero positive integer. A PID uniquely identifies a process. Create a new process, a process known as creating a child process (Child Process), the process of creating the child process is called parent. All processes will eventually fall back to their ancestral process of the process number 1, the body, this process is called init process is the kernel bootstrap process started after the first. Init process is playing the role of the end of the role of the parent process. Because the init process is never terminated, so the system is always convinced that it exists, and, where necessary to it as a reference. If a process in which all derived from the child process is terminated before the end, there will have to init for the reference situation. At this point those who have lost a parent on the child process to init as the parent process will be. Through the implementation of the ps-af command, you can list a number of parent process ID as a process. Linux provides a pstree command, allowing users to view system and each process is running between the inheritance. Directly on the command line input pstree, procedures will be listed in the system tree structure means the process of running the inheritance relationship between.Key words:linux; Process scheduling; Scheduling strategy; Memory management内存是Linux内核所管理的最重要的资源之一，内存管理系统是操作系统中最为重要的部分。
Linux的进程调度策略
Ｌｉｎｕｘ的进程调度策略 贺 炎１ 刘曙霞２ （１．西安电子科技大学计算机学院，陕西西安 ７１００７１；２．山东菏泽电视台，山东菏泽 ２７４０００） 摘 要 随着Ｌｉｎｕｘ操作系统在嵌入式系统方面的应用越来越广泛，关于增强并改进Ｌｉｎｕｘ对实时任务支持方面的研究也越来越多。
该文通过对Ｌｉｕｎｘ下进程调度的原理、依据以及调度算法、实时调度策略的全面分析，说明了Ｌｉｎｕｘ对普通进程和实时进程进行相应处理的过程。
同时为了改进Ｌｉｎｕｘ对实时任务的支持，提出了一种混合调度算法。
关键词 Ｌｉｎｕｘ，嵌入式系统，进程，实时性，调度策略。
中图分类号 ＴＰ３１６ １ 前 言 近年来，嵌入式Ｌｉｎｕｘ成为嵌入式系统方向上的一个研究热点，但是Ｌｉｎｕｘ本身作为一个分时操作系统并不能很好地支持实时任务，为了改进其实时性能，该文将对Ｌｉｎｕｘ的进程调度策略做出研究。
调度的实质是资源的分配，如何使系统能够保持较短的响应时间和较高的吞吐量，如何在多个可运行的进程中选取一个最值得运行的进程投入运行是调度器的主要任务。
进程调度包括两个方面的内容：何时分配ＣＰＵ时间（调度时机）即调度器什么时候启动；如何选择进程（调度算法）即调度器该怎么做。
进程调度算法是解决如何使资源分配策略最优化的关键。
一个好的调度算法应当考虑如下因素［１］： （１）公平：保证每个进程都得到合理的ＣＰＵ时间； （２）高效：使ＣＰＵ保持忙碌状态，即总是有进程在ＣＰＵ上运行； （３）响应时间：使交互用户的响应时间尽可能短； （４）周转时间：使批处理用户等待输出的时间尽可能短； （５）吞吐量：使单位时间内处理的进程数量尽可能多。
Ｌｉｎｕｘ本身作为分时操作系统，其系统目标为较好的平均系统响应时间和较高的吞吐量，而实时系统则主要考虑任务的按时完成、尽量减少进程运行的不可预测性等。
近年来，Ｌｉｎｕｘ在实时性支持方面取得了长足的发展，标准Ｌｉｎｕｘ系统支持实时和非实时（普通）两种进程，因此进程调度策略应该充分考虑普通进程和实时进程的差别。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Ｌｉｎｕｘ的进程调度策略 贺 炎１ 刘曙霞２ （１．西安电子科技大学计算机学院，陕西西安 ７１００７１；２．山东菏泽电视台，山东菏泽 ２７４０００） 摘 要 随着Ｌｉｎｕｘ操作系统在嵌入式系统方面的应用越来越广泛，关于增强并改进Ｌｉｎｕｘ对实时任务支持方面的研究也越来越多。
该文通过对Ｌｉｕｎｘ下进程调度的原理、依据以及调度算法、实时调度策略的全面分析，说明了Ｌｉｎｕｘ对普通进程和实时进程进行相应处理的过程。
同时为了改进Ｌｉｎｕｘ对实时任务的支持，提出了一种混合调度算法。
关键词 Ｌｉｎｕｘ，嵌入式系统，进程，实时性，调度策略。
中图分类号 ＴＰ３１６ １ 前 言 近年来，嵌入式Ｌｉｎｕｘ成为嵌入式系统方向上的一个研究热点，但是Ｌｉｎｕｘ本身作为一个分时操作系统并不能很好地支持实时任务，为了改进其实时性能，该文将对Ｌｉｎｕｘ的进程调度策略做出研究。
调度的实质是资源的分配，如何使系统能够保持较短的响应时间和较高的吞吐量，如何在多个可运行的进程中选取一个最值得运行的进程投入运行是调度器的主要任务。
进程调度包括两个方面的内容：何时分配ＣＰＵ时间（调度时机）即调度器什么时候启动；如何选择进程（调度算法）即调度器该怎么做。
进程调度算法是解决如何使资源分配策略最优化的关键。
一个好的调度算法应当考虑如下因素［１］： （１）公平：保证每个进程都得到合理的ＣＰＵ时间； （２）高效：使ＣＰＵ保持忙碌状态，即总是有进程在ＣＰＵ上运行； （３）响应时间：使交互用户的响应时间尽可能短； （４）周转时间：使批处理用户等待输出的时间尽可能短； （５）吞吐量：使单位时间内处理的进程数量尽可能多。
Ｌｉｎｕｘ本身作为分时操作系统，其系统目标为较好的平均系统响应时间和较高的吞吐量，而实时系统则主要考虑任务的按时完成、尽量减少进程运行的不可预测性等。
近年来，Ｌｉｎｕｘ在实时性支持方面取得了长足的发展，标准Ｌｉｎｕｘ系统支持实时和非实时（普通）两种进程，因此进程调度策略应该充分考虑普通进程和实时进程的差别。
２ Ｌｉｎｕｘ进程调度原理 进程是动态的，一个进程的所有信息都被放在其对应的ｔａｓｋ＿ｓｔｒｕｃｔ数据结构中。
每当一个新的进程创建时，一个新的ｔａｓｋ＿ｓｔｒｕｃｔ结构将分配给该进程，并同时增加到进程向量的数组中。
系统还有一个当前进程指针，用来指向当前正在运行的进程。
ｔａｓｋ＿ｓｔｒｕｃｔ实际上就是通常所说的“进程控制块”ＰＣＢ，它是系统对进程控制的惟一且最有效的手段。
２．１ 进程调度的依据 调度程序运行时，要在所有可运行状态的进程中选择最值得运行的进程投入运行。
在每个进程的ｔａｓｋ＿ｓｔｒｕｃｔ结构中有：ｐｏｌｉｃｙ、ｐｒｉｏｒｉｔｙ、ｃｏｕｎｔｅｒ、ｒｔ＿ｐｒｉｏｒｉｔｙ，这４项就是选择进程的依据［２］。
其中ｐｏｌｉｃｙ是进程的调度策略，用于区分实时进程和普通进程，实时进程优先于普通进程运行；ｐｒｉｏｒｉｔｙ是进程（包括实时和普通）的静态优先级；ｃｏｕｎｔｅｒ是进程剩余的时间片，它的起始值就是ｐｒｉｏｒｉｔｙ的值；由于ｃｏｕｎｔｅｒ在后面计算一个电子科技 ２００４年第５期（总第１７６期）Ｌｉｎｕｘ的进程调度策略 处于可运行状态的进程值得运行的程度ｇｏｏｄｎｅｓｓ时起重要作用，因此，ｃｏｕｎｔｅｒ也可以看作是进程的动态优先级。
ｒｔ＿ｐｒｉｏｒｉｔｙ是实时进程特有的，是实时进程之间的相对优先级，用于实时进程间的选择。
Ｌｉｎｕｘ用函数ｇｏｏｄｎｅｓｓ（）来衡量一个处于可运行状态的进程值得运行的程度。
该函数综合了以上提到的４项，还结合了一些其他的因素，给每个处于可运行状态的进程赋予一个权值（ｗｅｉｇｈｔ），调度程序以这个权值作为选择进程的惟一依据。
２．２ 进程调度的时机 进程调度的时机与引起进程调度的原因以及进程调度的方式有关。
Ｌｉｎｕｘ进程调度的时机主要有：进程状态转换的时刻，如进程终止、进程睡眠等；可运行队列中新增加一个进程时；当前进程的时间片用完时；进程从系统调用返回到用户态时；内核处理完中断后，进程返回到用户态时。
２．３ 进程调度的策略 首先，Ｌｉｎｕｘ 根据ｐｏｌｉｃｙ从整体上区分实时进程和普通进程（非实时进程），因为实时进程和普通进程度调度是不同的，实时进程应该先于普通进程而运行。
然后，对于同一类型的不同进程，采用不同的标准来选择进程：对于普通进程，Ｌｉｎｕｘ采用动态优先调度（多级反馈轮转调度算法）的策略，选择进程的依据就是进程ｃｏｕｎｔｅｒ的大小。
对于实时进程，Ｌｉｎｕｘ采用了两种调度策略，即ＦＩＦＯ（先来先服务调度）和ＲＲ（时间片轮转调度）。
３ 普通进程的调度策略－动态优先调度 选择进程的依据是进程ｃｏｕｎｔｅｒ的大小。
进程创建时，优先级ｐｒｉｏｒｉｔｙ被赋一个初值，一般为０～７０之间的数字，这个数字同时也是计数器ｃｏｕｎｔｅｒ的初值，进程创建时两者是相等的。
ｐｒｉｏｒｉｔｙ代表分配给该进程的时间片，ｃｏｕｎｔｅｒ表示该进程剩余的时间片。
在进程运行过程中，ｃｏｕｎｔｅｒ不断减少，而ｐｒｉｏｒｉｔｙ保持不变，以便在ｃｏｕｎｔｅｒ变为０的时候（该进程用完了所分配的时间片）对ｃｏｕｎｔｅｒ重新赋值。
当一个普通进程的时间片用完以后，并不马上用ｐｒｉｏｒｉｔｙ对ｃｏｕｎｔｅｒ进行赋值，只有所有处于可运行状态的普通进程的时间片（ｐ－＞ｃｏｕｎｔｅｒ＝＝０）都用完了以后，才用ｐｒｉｏｒｉｔｙ对ｃｏｕｎｔｅｒ重新赋值，这个普通进程才有了再次被调度的机会。
在普通进程运行过程中，ｃｏｕｎｔｅｒ的减小给了其他进程得以运行的机会，即进程正在运行时可以被其他ｃｏｕｎｔｅｒ值更大的进程中断，但只有当该进程的ｃｏｕｎｔｅｒ值减为０时才完全放弃对ＣＰＵ的使用，这就相当于优先级在动态变化，所以称之为动态优先调度。
Ｌｉｎｕｘ中某个进程的调度策略（ｐｏｌｉｃｙ）、优先级（ｐｒｉｏｒｉｔｙ）等可以作为参数由用户自己决定，具有相当的灵活性。
内核创建新进程时分配给进程的时间片缺省为２００ｍｓ（更准确的，应为２１０ｍｓ），用户可以通过系统调用改变它。
４ 实时进程的调度策略－ＦＩＦＯ和ＲＲ ４．１ 先来先服务调度（ＦＩＦＯ） 该策略是遵守ＰＯＳＩＸ１．ｂ标准的ＦＩＦＯ（先入先出）调度规则。
它会一直运行，直到有一个进程因Ｉ／Ｏ阻塞，或者主动释放ＣＰＵ，或者是ＣＰＵ被另一个具有更高ｒｔ＿ｐｒｉｏｒｉｔｙ的实时进程抢先。
４．２ 时间片轮转调度（ＲＲ） 该策略是遵守ＰＯＳＩＸ１．ｂ标准的ＲＲ（循环ｒｏｕｎｄ－ｒｏｂｉｎ）调度规则。
除了时间片有些不同外，这种策略与ＳＣＨＥＤ＿ＦＩＦＯ类似。
ＳＣＨＥＤ＿ＲＲ进程最先被调度并且拥有时间片，当ＳＣＨＥＤ＿ＲＲ进程的时间片用完后，就被放到ＳＣＨＥＤ＿ＲＲ队列和ＳＣＨＥＤ＿ＦＩＦＯ队列的末尾，并且允许同一优先级的其他进程运行；如果同一优先级没有其他进程，该进程将继续运行下一个时间片。
只要系统中有一个实时进程在运行，则任何普通进程都不能在任何ＣＰＵ上运行。
每个实时进程有一个ｒｔ＿ｐｒｉｏｒｉｔｙ，因此，可以按照ｒｔ＿ｐｒｉｏｒｉｔｙ在所有ＳＣＨＥＤ＿ＲＲ进程之间分配ＣＰＵ。
其作用与普通进程的ｐｒｉｏｒｉｔｙ作用一样。
只有ｒｏｏｔ用户能够用系统调用ｓｃｈｅｄ＿ｓｅｔｓｃｈｅｄｕｌｅｒ来改变当前进程的类型（ｓｙｓ＿ｎｉｃｅ，ｓｙｓ＿ｓｅｔｐｒｉｏｒｉｔｙ）。
Ｌｉｎｕｘ的进程调度策略 此外，内核还定义了ＳＣＨＥＤ＿ＹＩＥＬＤ，这并不是一种调度策略，而是截取调度策略的一个附加位。
如果有其他进程需要ＣＰＵ，它就提示调度程序释放ＣＰＵ。
５ 实时调度算法研究 作为一个分时系统，Ｌｉｎｕｘ的调度算法简洁、容易实现，却又不失公平高效。
但如果将Ｌｉｎｕｘ的调度算法［３］直接应用于实时要求很高的嵌入式系统中的话还是远远不够的。
在一个嵌入式ＲＴＯＳ中，必须能够保证应用中要求的低延迟和高度的可预测性。
仅凭标准Ｌｉｎｕｘ中对实时任务的简单支持措施无法对其时间要求作出保证。
因此，如果要将Ｌｉｎｕｘ应用在嵌入式应用中，必须增强扩充其实时性。
目前，实现Ｌｉｎｕｘ的硬实时性一般有“直接修改内核”和“增加一个实时内核”这两种途径，该文将讨论对其调度器进行改进，以增强它对实时任务的支持。
常用的实时调度算法有：基于优先级的调度算法；基于时间驱动的进程调度算法；基于比例共享的调度算法。
５．１ 基于优先级的调度算法 基于优先级的调度算法给每个进程分配一个优先级，在每次进程调度时，调度器总是调度那个具有最高优先级的任务来执行。
根据不同的优先级分配方法，基于优先级的调度算法可以分为如下两种类型：① 静态优先级调度算法：这类算法给系统中能够运行的所有进程都静态地分配一个优先级。
静态优先级的分配可以根据应用的属性来进行，比如任务的周期、用户优先级或者其他预先确定的策略。
ＲＭ（Ｒａｔｅ－Ｍｏｎｏｔｏｎｉｃ）调度算法是一种典型的静态优先级调度算法，它根据任务执行周期的长短来决定调度优先级，执行周期小的任务具有较高的优先级。
② 动态优先级调度算法：这类算法根据任务的资源需求来动态地分配任务的优先级，其目的就是在资源分配和调度时有更大的灵活性。
非实时系统中就有很多这种调度算法，例如短作业优先的调度算法。
在实时调度算法中，ＥＤＦ算法是使用最多的一种动态优先级调度算法，该算法给就绪队列中的各个任务根据它们的截至期限（Ｄｅａｄｌｉｎｅ）来分配优先级，具有最近截至期限的任务具有最高的优先级。
５．２ 基于比例共享的调度算法 基于优先级的调度算法提供一种硬实时的调度，算法简单有效，但在很多情况下不适合使用，例如像实时多媒体会议系统这样的软实时应用。
对于这种软实时应用，使用一种比例共享式的资源调度算法（ＳＤ算法）更为合适。
比例共享调度算法指基于ＣＰＵ使用比例的共享式调度算法，其基本思想就是按照一定的权重（比例）对一组需要调度的任务进行调度，使其执行时间与权重完全成正比。
可以通过两种方法来实现比例共享调度算法：① 是调节各个就绪进程出现在现在调度队列队首的频率，并调度队首的进程执行；② 是逐次调度就绪队列中的各个进程投入运行，但根据分配的权重调节分配给每个进程的运行时间片。
比例共享算法包括轮转法、公平共享、公平队列、彩票调度法等几类。
５．３ 基于时间驱动的进程调度算法 对于那些具有稳定、已知输入的简单系统，可以使用时间驱动（Ｔｉｍｅ－Ｄｒｉｖｅｎ：ＴＤ）的调度算法，它能够为数据处理提供良好的预测性。
该算法本质上是一种设计时就确定下来的离线的静态调度方法。
在系统的设计阶段，在明确系统中所有处理的情况下，对于各个任务的开始、切换以及结束时间等事先做出明确的安排和设计。
并适合于那些很小的嵌入式系统、自控系统、传感器等应用环境。