Linux 2.6调度优先级与时间片算法
linux系统进程调度
Linux系统进程调度姓名: 班级: 学号：摘要Linux 自出现以来以惊人的速度在服务器和桌面系统中获得了成功。
本文介绍了现代操作系统常见进程调度算法以及linux2.6.32中进程调度的策略并根据具体例子对Linux进程调度过程进行了具体分析。
一、最常用的操作系统调度算法有以下几种;1.先来先服务调度算法调度程序按照进程在就绪队列中的提交顺序或变为就绪状态的先后进行调度,是一种最普遍和最简单的方法,所需的系统开销最小。
该算法对所有的进程一视同仁,不能反映对实时进程或特殊要求的进程的特殊处理,在实际操作系统中,很少单独使用该算法,而是和其它一些算法配合起来使用。
2.高优先权优先调度算法1 优先权类型。
1)静态优先权，他是在创建进程时确定的，且在进程的整个运行期间保持不变。
2)动态优先权，他是在创建进程时所赋予的优先权，是可以随进程的推进或随其等待时间的增加而改变的，以便获得更好的调度性能。
2优先权调度算法的类型。
1)非抢占式优先权算法。
在这种方式下，系统一旦把处理机分配给就绪队列中优先权最高的进程后，该进程便一直执行下去，直至完成；或因发生某事件使该进程放弃处理机时，系统方可再将处理机重新分配给另一优先权最高的进程。
2)抢占式优先权调度算法。
这种方式下，系统同样是把处理机分配给优先权最高的进程，使之执行。
但在其执行期间，只要又出现了另一个其优先权更高的进程，进程调度程序就立即停止当前进程(原优先权最高的进程)的执行，重新将处理机分配给新到的优先权最高的进程。
3.时间片的轮转调度算法时间片轮转法一般用于进程调度，每次调度，把CPU分配队首进程，并令其执行一个时间片。
当执行的时间片用完时，由一个记时器发出一个时钟中断请求，该进程被停止，并被送往就绪队列末尾；依次循环。
4.多级反馈轮转法它是在优先级和轮转法的基础上,根据进程加入就绪队列的原因不同,将就绪队列分为多个就绪队列,不同的队列之间优先权不同,而同一个队列内的进程优先权相同而按照先来先服务的原则排列。
Linux2.6进程调度策略分析
（ ｕ ｅ Ｆｎ ｎ ｅ Ｔ ｘｔ ｎＣ ｌｇ ， ｈ ｎ ４ ０ ６ ， ｉａ Ｈ ｂ ｉ ｉ ｃ ＆ ａ ａｉ ｏｌ ｅＷｕ ａ ３ ０ ４Ｃｈ ） ａ ｏ ｅ ｎ
Ａｂ ｔ ａ ｔ ｈ ｒ ｃ ｓ ｆｓ ｈ ｄ ｌ ｇ Ｌ ｎ ｘ ． ｌ ｓ ｌ ｌｔｄ ｔ ｏ ｆ ｈ ａａ ｓ ｕ ｔ ｒ ， ｄ ｔｉ ｄ ｄ ｓ ｒ ｔ ｎ ｏ ｅ ｔ ｎ ｓｒ ｃ ： ｅｐ ｏ ｅ ｓｏ ｅ ｕｉ ｉｕ ２６ ｃｏ ｅｙｒ ａｅ ｏｓ ｍｅ ｏ ｅｄ ｔ ｔ ｃｕ ｅａ ｅａｌ ｅ ｃ ｉ ｉ ｆ ｍｉ ｇ Ｔ ｃ ｎ ｅ ｔ ｒ ｅ ｐｏ ｈ ｔ ｉ ｏ ｒ ｃ ｓ ｃ ｅ ｕ ｉ ｇｓ ｈ ｄ ｌ ｇ ａｇ ｒ ｈ ｎ ｃ ｅ ｕｉ ｇ ｓ ａｅ ｉ ｓ ｏ ｈ ｔ ｔｇ ， ｅ ｅ ｉ ｒ ｖ ｍｅ ｔ ｍａ ｅ ｔ ｅ ｐ ｏ ｅ ｓ ｆ ｐ ｏ ｅ ｓ ｓ ｈ ｄ ｌ ， ｅ ｕ ｉ ｌｏ ｉ ｍｓ ａ ｄ ｓｈ ｄ ｌ ｔ ｔｇ ｅ ｎ ｔｅ ｓ ａｅ ｙｔ ｓ ｍｐ ｏ ｅ ｎ ｓ ｎ ｃ ｎ ｔ ｎ ｒ ｒ ｈ ｋ ｈ ｒ ｃ ｓ
摘 要 ：分析 了 Ｌｎ ｘ ．进程 调度 密切 相 关的一 些数 据结 构 ，详 细描 述 了进程 调度 的 时机 、调度 的 策略和调 度 的算 法 ｉｕ２６ 上 的策 略 ， 些 改进使 得 Ｌｎ ｘ ． 这 ｉｕ２ ６进程调 度 程序 实现 了 ｏ （ ） 度 算 法 ， １调 支持 抢 占式调 度 ，并且增 强 了对 实时任 务和 Ｓ ＭＰ 的 支持 。
ｓｈｄｌ ｐｅ ｅｔ Ｌｎ ｘ ． Ｏ １ｓｈｄห้องสมุดไป่ตู้ｉ ｌｏ ｔｍ ｔ ｐ ｏ ｈｅ ｒ ｍ ｔ ｅｓ ｅｕｎ ， ｄｅｈ ｃｄｒａ ｔ ｓｓ ｎ ｃｅｕｅ ｉ ｌ ｎｓ ｉｕ２６ （） ｅｕ ｎ ａ ｒｈ ｓ ｐ￣ｔ ｅ ｐ ｖ ｃ ｄ ｌ ｇ ｎ ｎ ａ ｅ ｌ ｍｅｔ ｋ ｄ ｒｍ ｍ ｃ ｌ ｇ ｇｉ ｏ ｕ ｐｅ ｉ ｈ ｉ ａ ｎ ｅ－ ｉ ａ ａ
Linux 2.6 调度系统分析
1．前言Linux 的市场非常广阔，从桌面工作站到低端服务器，它都是任何商用操作系统的有力竞争对手。
目前，Linux 正全力进军嵌入式系统和高端服务器系统领域，但它的技术缺陷限制了它的竞争力：缺乏对实时任务的支持，多处理机可扩展性差。
在 2.4 内核中，造成这两个弱项的关键原因之一就是调度器设计上的缺陷。
2.6 调度系统从设计之初就把开发重点放在更好满足实时性和多处理机并行性上，并且基本实现了它的设计目标。
主要设计者，传奇式人物 Ingo Molnar 将新调度系统的特性概括为如下几点：∙继承和发扬 2.4 版调度器的特点：o交互式作业优先o轻载条件下调度/唤醒的高性能o公平共享o基于优先级调度o高 CPU 使用率o SMP 高效亲和o实时调度和 cpu 绑定等调度手段∙在此基础之上的新特性：o O(1)调度算法，调度器开销恒定（与当前系统负载无关），实时性能更好o高可扩展性，锁粒度大幅度减小o新设计的 SMP 亲和方法o优化计算密集型的批处理作业的调度o重载条件下调度器工作更平滑o子进程先于父进程运行等其他改进2.4 的就绪队列是一个简单的以 runqueue_head 为头的双向链表，在 2.6 中，就绪队列定义为一个复杂得多的数据结构 struct runqueue，并且，尤为关键的是，每一个 CPU 都将维护一个自己的就绪队列，--这将大大减小竞争。
O(1)算法中很多关键技术都与 runqueue 有关，所以，我们对调度器的分析就先从 runqueue 结构开始。
1) prio_array_t *active, *expired, arrays[2]runqueue 中最关键的数据结构。
每个 CPU 的就绪队列按时间片是否用完分为两部分，分别通过 active 指针和 expired 指针访问，active 指向时间片没用完、当前可被调度的就绪进程，expired 指向时间片已用完的就绪进程。
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时间片。
操作系统的调度算法优先级时间片和占式调度
操作系统的调度算法优先级时间片和占式调度操作系统的调度算法：优先级、时间片和抢占式调度操作系统是计算机系统中的一个核心组件，用于管理和控制计算机的硬件和软件资源，以提供良好的用户体验和系统性能。
在操作系统中，调度算法是实现任务分配和资源管理的关键。
本文将介绍三种常见的调度算法：优先级调度、时间片轮转调度和抢占式调度。
一、优先级调度算法优先级调度算法是根据任务的优先级安排任务的执行顺序。
每个任务都有一个优先级值，数值越高表示优先级越高。
当一个任务就绪并等待执行时，调度器会选择优先级最高的任务来执行。
优先级调度算法可以保证高优先级任务及时得到执行，但可能会导致低优先级任务出现饥饿现象。
实际上，优先级调度算法可以分为静态优先级和动态优先级两种类型。
静态优先级是在任务创建时分配的，不会改变。
动态优先级根据任务的运行情况和系统状态进行动态调整，以提高系统的公平性和性能。
二、时间片轮转调度算法时间片轮转调度算法是一种周期性调度算法，每个任务被分配一个固定的时间片（时间段），当任务的时间片用完后，调度器会将任务挂起，并将CPU 分配给下一个任务执行。
当所有任务都执行完一次后，调度器会重新分配时间片，继续按照顺序执行任务。
时间片轮转调度算法可以保证任务的平均执行时间，并且避免了长时间任务的霸占资源问题。
然而，如果任务的时间片设置得过小，则会增加任务切换的开销。
如果任务的时间片设置得过大，则可能出现对实时任务响应时间的影响。
三、抢占式调度算法抢占式调度算法是一种灵活的调度策略，允许更高优先级的任务打断正在执行的低优先级任务，以确保高优先级任务的及时响应。
当一个任务就绪并具备运行条件时，调度器会立即安排其执行，无论当前是否有其他任务在执行。
抢占式调度算法可以有效地提高系统的响应速度和实时性，但可能会导致任务切换的频繁发生，增加了系统开销。
为了平衡性能和实时性的需求，抢占式调度算法通常会和其他调度策略结合使用，例如优先级和时间片轮转。
Linux2.6进程调度算法
20
Company
Logo
O(1) 最佳优先级的选取
进程调度的本质就是在当前可运行的进程集合中选择一个最 佳的进程，这个最佳则是以进程的动态优先级为选取标准的。 早期内核选取最佳优先级进程的方法是依次遍历每个可运行 状态的进程，最终选取一个优先级最高的进程。它的时间复 杂度是 O(n) 。 而在 O(1) 算法中，不管是过期进程集合还是活跃进程集合 ，都将每个优先级的进程组成一个链表，因此每个集合就有 140 个不同优先级的进程链表。同时，两个集合中还采用优 先级位图来标记每个优先级链表中是否存在进程。 由于进程优先级个数是定值，因此查找最佳优先级的时间恒 定，它不会像以前的方法那样受可执行进程数量的影响。 21
4
Company
Logo
进程分类
进程可以被分为两种类型： I/O 消耗型和 CPU 消耗型。 I/O 消耗型进程频繁使用 I/O 设备，并且大部分时间都处于 等待状态。为了使系统有较强的响应能力， I/O 消耗型进程 必须很快能被唤醒，以实现进程的切换 ; 否则，用户会感到 系统反应迟钝。大多数人机交互进程都属于 I/O 消耗型进程 。 CPU 消耗型进程则大部分时间都在占用 CPU ，它们常常位 于后台运行，并且没有过多的 I/O 需求，因此系统并不需要 对这类进程做出快速反应。这类进程的典型代表为用于科学 计算的进程。
13
Company
Logo
过期进程和活动进程
运行态和就绪态与可运行状态 (TASK_RUNNING) 的关系。 可运行状态进程分为两类：活动进程，它们还没有用完他们的 时间片，等待被运行；过期进程，已经用完了的时间片，在其 他进程没有用完它们的时间片之前，它们不能再被运行。 调度程序的工作就是在活动进程集合中选取一个最佳优先级的 进程，如果该进程时间片恰好用完，就将该进程放入过期进程 集合中。 在可运行队列结构中， arrays 数组的两个元素分别用来表示 刚才所述的活动进程集合和过期进程集合。此外， active 和 expired 两个指针也分别直接指向这两个集合。
操作系统时间片轮转算法与优先级调度算法
操作系统时间片轮转算法与优先级调度算法操作系统作为计算机的核心，需要负责管理和分配系统资源的功能。
其中，调度算法是操作系统中非常重要的一个功能，它决定了如何分配CPU时间，因此直接影响系统的性能和响应速度。
本文将介绍两种操作系统中常用的调度算法：时间片轮转算法和优先级调度算法。
时间片轮转算法时间片轮转算法（Round Robin）是一种基本的调度算法，它是多道程序设计中常用的一种算法。
在内存中同时存放多个进程，并根据每个进程的优先级轮流分配 CPU 时间，以保证每个进程都能得到一定的CPU时间片，从而保证操作系统的公平性和系统的稳定性。
基本思想时间片轮转算法的基本思想是：将每个进程分配相同长度的CPU时间片，一旦时间片用完，立即将该进程挂起，并将 CPU 分配给下一个进程。
这样就可以保证每个进程都有相同的机会获得 CPU 时间，避免了某个进程长时间霸占CPU而导致其他进程无法运行的情况。
算法流程时间片轮转算法的具体实现过程如下：1.将所有待运行的进程加入到就绪队列中；2.从就绪队列中取出第一个进程，将其运行指定时间片长度的时间；3.如果该进程在运行时间片结束之前自己退出，那么直接将其从就绪队列中取出，释放资源；4.如果该进程在运行时间片结束之前没有自己退出，那么将其挂起放到队列的尾部，然后将 CPU 分配给下一个进程，重复2-4步骤，直到所有进程执行完毕。
算法优点时间片轮转算法的优点如下：1.公平：每个进程都能得到相同长度的时间片，避免了某个进程长时间霸占CPU的情况，从而保证了每个进程都会运行；2.适用：时间片轮转算法适用于多任务并发的环境下，可以有效地避免死锁和饥饿现象；3.高效：时间片轮转算法可以保证 CPU 的高效利用，能够最大限度地提高 CPU 的性能。
算法缺点时间片轮转算法的缺点如下：1.精度问题：时间片长度不能太长，否则会导致某些进程长时间等待CPU时间片；2.资源浪费：如果一个进程只需要很短的时间就可以完成任务，但由于时间片的限制而占用CPU的时间，这就是一种资源浪费。
Linux2.6内核调度分析及实验设计
在现代操作系统中 ， 进程调度一直是一 个核心问题 ， 它往往不单独 使用其 中的一种调度方法 ， 而是综合运用几种基本 的调度 方法 ， 进程调 度策略的优劣对整个系统性 能有 至关重要 的影 响。 ｉｕ２６引入了新的 Ｌｎ ｘ． 调度 算法 ， 具有 完全实现 Ｏ（ ） １算法 、 强了 Ｓ 增 ＭＰ可扩展性 、 强化 Ｓ ＭＰ 亲和力 、 增强了对软实时性的支持 、 公平性 等特点ｌ 本文对 Ｌｎｘ ． 的 ｌ ｌ 。 ｉ ２６ ｕ 调度过程及算法进 行了详 细分析 ， 并设计 了 Ｌｎ ｘ ｉｕ 调度实验 。
１Ｌｎ ｘ ． ．ｉｕ ２６内核 调 度 机 制 １１ ｉｕ ． Ｌｎ ｘ内核 调 度 数 据 结 构
—
进程控制块 Ｐ ＢＰｏｅｓ ｏｔ ｌ ｌ ｋ ｔ ｋ ｓｕ ｔ 系统 中最 为重 Ｃ （ｒ ｓ ｎｒ ｏ ）ａ — ｔ ｃ 是 ｃ Ｃ ｏＢ ｃ ｓ ｒ 要 的数据结构之一 ，用来存 放进程所必需的各种信息 ， 包括进程 的类 型、 进程状态 、 优先级 、 时钟信息等 。
科技信息．
博 士 ・ 家论 坛 专
Ｌｎ ｘ ． 核 调度 分 析 及 实 验 设 计 ｉｕ ２６内
安徽 科技 学 院理 学院 赵艳 红 沈 峰 段 汉根
［ 摘 要］ 本文剖 析 了 Ｌｎ ｘ ． ｉｕ ２６内核 重要数 据 结构 ， 程调度 依据 、 进 调度 时机 、 度 策略 ， 调 并详 细分析 了 Ｌｎ ｘ ， ｉｕ ２６进程 调度 算法 。 Ｌｎ ｘ ． ｉｕ ２６内核 实现 了 Ｏ（ ） １ 的特性 ， 据实验 结果， 明了 Ｌｎ ｘ ． 根 证 ｉｕ２６具有很好 的实时性 ， 多任务下有更 高的 Ｃ Ｕ使 用率。 Ｐ
一
ｐｅ 就是 当前进程结构 ｒｖ
Linux 2.6内核进程调度分析
非抢 占式 内核不适 用于实 时应用 ； 内核 中也存在优 先级翻
０ 引 言
从上世纪 ９ ｏ年代 以来 ， Ｎ ／ ｉｕ Ｇ Ｕ Ｌｎｘ系统在各个 领域 已经 得
转的问题。
Ｌｎｘ２ ６调度 系统从设计 之初就 把重点放 在更好满 足实 ｉ ． ｕ 时性和多处理机并 行性 上 ， 并且基本实现了它的设计 目标。
・对高负载 的系统来说 ， 预定义 的时 间片太长
时间片是在每个时期调度 程序赋 给各进程运行 的时间 。系
为交 互式 进程 ， 即使时 间片用 完 ， 还是保 留在 当前 的就 绪队 也
列， 这样极大提高 了交互式进程的优先级 ， 保证 了交互式进程 的
统 的响应依赖 于可运 行 的时 间片。对 于高系 统负 载的 高端机
０ ｎ 级 ， 当前就绪进程的个数 ， （ ） ｎ为 即调度时 间随 当前就绪进程 数的增 多而增加 。
程的优先 级 ， 同时把对进程优先级的计算分散 于多处进行 ， 这样 无论系统多少进程 ， 进程切换的时间始终是常数。其次 ， 新的算
法引入了更加 精确 的交 互式进程 的认定 机制 ， 旦进程被 确认 一
ａ ｖ ｎ ａ ｅ ｏ ａ ｅ ｉ ｉ ｕ ． ｒ ｏｎ ｅ ｕ ． ｅ ｏ ｉ ｉｎ ｂ ｕ ｈ ｍｐ ｏ ｅ ｎ ｆＬ ｎ ｘ ２ ６ ｓ ｈ ｄ ｌ ｌ ｏｉｈ ａ ｅ ｉ ｔ ｄ ｃ ｄ ｄ ａ ｔｇ ｓ ｃ ｍｐ ｄ ｗ ｔ Ｌ ｎ ｘ２ ４ ａ ｅｐ ｉ ｔｄ ｏ ｔ Ｔ ｐｎ ｏ ｓ ａ ｏ ｔｔ ｅ ｉ ｒ ｖ ｍｅ ｔ ｉ ｕ ． ｃ ｅ ｕ ｅ ａｇ ｒ ｍ ｒ ｎ ｒ ｕ ｅ ． ｒ ｈ ｈ ｏ ｔ ｏ Ｋｅ ｗｏ ｄ ｙ ｒｓ Ｐ ｏ ｅ ｓ ｓ ｈ ｄ ｌｒ Ｌ ｎ ｘ ｒ ｃ ｓ ｃ ｅ ｕｅ ｉ ｕ
先来先服务,时间片调度,优先级调度算法实验报告
先来先服务,时间片调度,优先级调度算法实验报告先来先服务、时间片调度、优先级调度算法实验报告1. 引言本次实验旨在研究和比较先来先服务（FCFS）、时间片调度（RR）和优先级调度（Priority Scheduling）三种常见的进程调度算法。
进程调度是操作系统中的重要概念之一，合理的进程调度算法可以提高系统效率，优化资源利用。
2. 先来先服务算法•先来先服务算法是一种简单的调度算法，按照进程到达的顺序进行调度。
•优点：简单易实现，适用于长作业。
•缺点：容易造成短作业等待时间过长，无法满足实时性要求。
3. 时间片调度算法•时间片调度算法将CPU时间划分为一段一段的时间片，每个进程在一个时间片内执行。
•若进程未完成，会被放入就绪队列的末尾，等待下一个时间片。
•优点：公平，适用于短作业，能满足实时性要求。
•缺点：时间片过长，会导致长作业等待时间过长。
4. 优先级调度算法•优先级调度算法根据进程的优先级来确定调度顺序，拥有最高优先级的进程先执行。
•静态优先级可在创建进程时确定，动态优先级可根据进程执行情况进行调整。
•优点：适用于实时任务和长作业，可根据需求调整优先级。
•缺点：可能导致低优先级任务等待时间过长，存在优先级反转问题。
5. 实验结果与分析通过对三种调度算法的实验测试，得出以下结论：•FCFS算法在长作业的情况下表现较好，但对于短作业不友好，容易造成长时间等待；•RR算法适用于短作业，能保证公平性，但时间片过长可能导致长作业等待时间过长；•优先级调度算法较为灵活，能满足实时性要求，但可能导致低优先级任务长时间等待。
综上所述，不同的调度算法适用于不同的场景，根据需求选择合适的算法可提高系统效率。
6. 总结本次实验对先来先服务、时间片调度和优先级调度算法进行了研究和比较。
通过对三种算法的分析，我们可以根据任务特点和需求选择合适的调度算法，以提高系统的效率和资源利用率。
同时，在实际应用中也需要考虑进程的实时性要求，避免长时间等待等问题的出现。
优先级加时间片轮转进程调度算法_概述及解释说明
优先级加时间片轮转进程调度算法概述及解释说明1. 引言1.1 概述本文旨在介绍优先级加时间片轮转进程调度算法。
进程调度是操作系统中的重要组成部分，它决定了多个进程之间的执行顺序和时间配比。
优先级调度算法和时间片轮转调度算法都是常用的进程调度算法，在不同场景下各具优缺点。
而结合这两种算法进行设计与实现，则能充分发挥它们的优势，提高系统的性能和效率。
1.2 文章结构本文将按照以下结构进行介绍：首先概述文章内容，明确文章重点和目标；然后详细讲解优先级调度算法，包括其定义、原理和实现方式；接着介绍时间片轮转调度算法，包括其定义、原理以及运行机制；随后探讨选择何种调度策略的问题；最后以设计思路与实现示例为基础，对结合优先级与时间片轮转调度算法进行分析，并进行性能评估和对比研究。
1.3 目的本文旨在深入探讨优先级加时间片轮转进程调度算法，阐明其背后的原理与机制，并通过实例演示说明如何设计与实现该算法。
此外，本文还将对该调度算法的优缺点进行分析，并提出进一步研究的方向和展望。
通过本文的阐述，读者能够全面了解并掌握优先级加时间片轮转进程调度算法的实现与应用。
2. 优先级调度算法:2.1 定义与原理:优先级调度算法是一种基于进程优先级的调度方法。
每个进程被赋予一个优先级，优先级越高的进程被认为是更重要的任务，应该在其他进程之前得到处理器资源。
该算法的原理是根据进程的优先级来确定调度顺序。
当有多个就绪状态的进程等待执行时，调度程序会选择具有最高优先级的进程执行。
如果两个或多个进程具有相同的优先级，则采用其他策略（如轮转或抢占）来选择将要运行的进程。
2.2 实现方式:实现这种调度算法可以采用不同的方法。
一种常见的方式是为每个进程分配一个固定的静态优先级，其值通常在范围内确定（比如0到255），其中较大的数字表示较高的优先级。
另一种方式是动态地根据某些因素为进程分配优先级，如当前执行时间、等待时间、紧迫性等。
在操作系统中，可以使用一个队列来存储就绪状态下各个进程，并按照它们的优先级进行排序。
优先级 时间片轮转调度算法
优先级调度算法和时间片轮转调度算法是两种不同的操作系统进程或任务调度算法。
下面我将分别解释这两种算法：
1. 优先级调度算法：
优先级调度算法是一种非抢占式的调度算法，在这种算法中，每个进程被赋予一个优先级，调度器总是选择优先级最高的进程来执行。
如果多个进程具有相同的优先级，则可以按照FCFS （先进先出）的方式进行调度。
这种算法的优点是简单且易于实现，但可能导致某些进程长时间得不到执行，因此公平性较差。
2. 时间片轮转调度算法：
时间片轮转调度算法是一种抢占式的调度算法，在这种算法中，每个进程被分配一个时间片，当进程在执行过程中用完时间片后，调度器将剥夺该进程的CPU并分配给下一个等待的进程。
如果一个进程在时间片用完之前阻塞或完成，调度器将进行特殊处理。
这种算法的优点是公平性较好，每个进程都有机会获得执行，但实现起来相对复杂。
优先级调度算法和时间片轮转调度算法各有优缺点，适用于不
同的场景。
在实际应用中，操作系统通常会根据具体需求选择适合的调度算法。
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 2.6 进程调度分析
/* -1 unrunnable, 0 runnable, >0 stopped */
2.6与2.4的宏定义数值上有较大的差别
2.6新增了两种状态：TRACED、DEAD TASK_DEAD是表示已经退出且不需父进程回 收的进程的状态。 TASK_TRACED供调试使用（似乎有 STOPPED有点儿重复？）
include/asm-i386/bitops.h中寻找最高优先级函数
– 按宏定义，会生成160bit的位数组（5个 long)，构成一张表。 – 每一位对应一个优先级，该优先级有active 状态（时间片未用完）的，在相应位置1, 否则置0。 – 从右向左位扫描1，得到优先级最高（值最 小）的优先级号k – 进入queue[k]数组
TASK_ZOMBIE一个已经终止的但仍保留有任
务结构的进程（已经死了，户口未注销）。
TASK_RUNNING 就绪态(准确的说应该是
task_runable)
TASK_INTERRUPTIBLE、
TASK_UNITERRUPTIBLE 不同深度的睡眠态
TASK_STOPPED 描述一个已经停止的进程，
为什么用long不用char? 扫描算法，bitmap[0]~bitmap[3]， if(bitmap[0]!=0) …else…
Source Insight 简介
该软件符合优秀软件的设计标准：用户
不需要专门的学习就能使用。
Linux 2.6调度系统的特性(1)
继承和发扬 2.4 版调度器的特点： 交互式作业优先 轻载条件下调度/唤醒的高性能 公平共享 基于优先级调度 高 CPU 使用率 SMP 高效亲和 实时调度和 cpu 绑定等调度手段
Linux2.6进程调度机制的剖析
（ ）主动进 入休 眠状 态． ３
２ ２ 调 度 策 略 ． 在 Ｉｎ ｘ ． ｕ ２ ６中 ， 有 三 种 调 度 策 略 ：Ｓ ＨＥ ｉ 仍 Ｃ Ｄ
Ｎ Ｏ ＲＭ Ａ Ｌ 、 Ｃ Ｈ ＥＤ Ｓ
—
ＦＦ 和 Ｓ ＩＯ ＣＨＥ — ． 者 Ｄ ＲＲ 前
１ ｉｕ ２ ４内核 进 程 调 度 的 缺 陷 Ｌ ｎ ｘ ．
导 致 大 部 分 的 Ｃ Ｕ 处 于 空 闲状 态 ， 而 影 响 Ｓ Ｐ Ｐ 从 Ｍ 的效率 ．
２ ｉｕ ２ ６内核 进 程 调 度 分 析 Ｌ ｎ ｘ ．
２ １ 调 度 时 机 ．
（） ２ 休眠进 程被 唤醒 时 ；
（ ）从 ＴＡＳ — ＮＴ ＲＲ Ｔ Ｂ 状 态 中 被 ３ Ｋ Ｉ Ｅ ＵＰ Ｉ Ｉ Ｅ
文章 编 号 ：１ ０ — ９ （ ０ ７ ０ ５ ０ ０ ０ ０ １ ０ ２ ０ ） ４ ０ ２ — ４ １
Ｌｎ ｘ ． ｉｕ ２ ６进 程 调 度 机 制 的 剖析
何 克 右 ，周 彩 贞
（ 汉婵 工 大 学 计 算 机 学 院 ， 汉 ４ ０ ６ ） 武 武 ３０ ３
摘 要 ：削述 了 Ｉｎ ｘ ． ． ｕ ２ ４内核 进 程 调 度 系 统 存 在 的 缺 陷 ， 细 分 析 了 Ｉｎ ｘ ． ｉ 详 ｄ ｕ ２ ６内 核进 程 调 度 的 时
维普资讯
第 ４ 卷 第 ４期 ｌ
２０ ０ ７年 ｌ ２月
华 中 师 范 大 学学 报 （ 自然 科 学 版 ）
．
Ｖ ｏｌ４１ ＮＯ． ＿ ４
Ｄｅ ． ２ ７ ｃ ＯＯ
Ｊ ＯＵ ＲＮＡＩ ＯＦ ＨＵＡＺＨ０ＮＧ ＮＯＲＭ ＡＩ ＵＮＩ ＲＳ ＴＹ（ ｔ ｃ． ＶＥ Ｉ Ｎａ ．Ｓ ｉ ）
基于LINUX2.6内核进程调度策略分析
的Ｓ ＭＰ性 能 瓶颈 。下 面介 绍 其 中一 些 重要 成 员 ： ２２１优 先 级 数组 ．． ２６内核 中 ， 个 Ｃ Ｕ拥 有 一个 就 绪 队列 ， 个 就 绪 队 列都 ． 每 Ｐ 每
ＬＮ Ｘ是 一 个 多 用 户 多 任 务 ． 支 持 多处 理器 体 系结 构 的 ＩＵ 并 操作 系 统 ． 由于 其 非 商 业 化 、 代 码 免 费 开 放 、 合 Ｐ ＳＸ 规 且 源 符 ＯＩ 范、 容 Ｕ Ｉ 兼 Ｎ Ｘ等 特 点 ， 目前 已成 为 ＷＩ Ｄ ＷＳ系列 操 作 系统 强 ＮＯ 有 力 的 竞争 对 手 进 程 调 度是 操 作 系统 的重 要 功能 之 一 。 Ｉ Ｕ ２ ＬＮ Ｘ ． ６内核 在对 进程 调 度算 法 方 面 ， 码 几乎 是 全 新 的 ， 采 用 了一 种 叫 做 ０ １ 代 它 （） 调度 程 序 的 新调 度 程 序 ． 决 了先 前 版本 ＬＮ Ｘ调 度 程 序 的许 解 ＩＵ 多不 足 。 增加 了对 抢 占 内核 的支 持 。 文 对 ０ １ 度 程 序及 其 并 本 （） 调 相 关 数 据结 构 进 行 了分 析 。
ｓｒ ｃ ｆｏ ｔｕ ｔｐ ｉ
＿ ＿
ａ ａ｛ ￣ｙ 进 程数 目 ，
．
ｉｔ ｎ ｎｒ ａｔｅ ｃｖ ： ｉ
ｕ ｓ ｎ ｄｌｎ ｉ ａ ［ ＩＭＡ Ｉ Ｅ１ 优 先 级 位 图 ｝ ｎ ｉ ｅ ｇ ｂ ｍ ｐＢ Ｔ Ｐ Ｓ Ｚ ｇ ｏ ｔ ； ，
ｓ ｕｔｉ ｅｄ ｑｅ ｅ ｘ Ｐ Ｉ１ ｔ ｃ ｌ ｔ ａ ｕｕ［ ｒ ｓ ｈ ＭＡ — Ｒ Ｏ ；
２ ０（） 度 程序 相 关数 据 结 构 、 １调
有两 个 优 先 级数 组 ．一个 是 ａｔ ｅ和 ｅｐｒｄａｔ ｅ 向时 间 片 ｃｖ ｉ ｘｉ ． ｉ 指 ｅ ｃｖ 未用 完 的就 绪 进 程 ，ｘ ｉｄ指 向时 间片 已用 完 的 就 绪 进 程 。 它 ｅｐｒ ｅ 们都 是 ｐ ｏ ａｒｖ 构 。定 义如 下 ： ｉ ｆ ｒ 结 ａ
linux2.6O(I)调度算法实验
linux2.6 O(1)调度算法实验3/26/2008目录linux2.6 O(1)调度算法实验......................................................................... 错误!未定义书签。
1前言........................................................................................................... 错误!未定义书签。
2O(1)算法测试........................................................................................... 错误!未定义书签。
2.1测试代码....................................................................................... 错误!未定义书签。
2.2运行结果....................................................................................... 错误!未定义书签。
3附录........................................................................................................... 错误!未定义书签。
3.1Linux 2.6 O(1) 调度算法分析................................................. 错误!未定义书签。
3.2Linux 2.6 O(1) 调度算法数据结构......................................... 错误!未定义书签。
Linux实时调度内容概括
Linux2.6.36中实时调度分析Linux/kernel/sched_rt.c(1800lines)Linux实时调度分为先进先出调度和时间片轮转SCHED_FIFO：适用于对响应时间要求比较高，而起执行时间比较短的实时进程。
实时进程按照其入队的先后顺序执行，除非因中断等原因主动放弃cpu或者是遇到更高优先级进程抢断，否则该进程一直占用cpu；SCHED_RR：适用于对时间响应要求高而且执行时间较长的进程，各进程轮询使用cpu，当进程的时间片用完时将从运行队列出队，然后加入队尾。
优先级：实时进程的优先级为0—99，非实时进程的优先级是100—139，所以任何时候只要有实时进程，先执行的都是实时进程。
这些优先级在linux-2.6.36\include\linux\sched.h 文件中的struct task_struct中有定义：struct task_struct{……unsigned int rt_priority;unsigned int policy;……};policy有是个状态SCHED_FIFO SCHED_RR SCHED_OTHER SCHED_YIELD SCHED_LITMUS SCHED_IDLE SCHED_BATCH前三种表示三中不同的调度方式，最后两种属于特殊的，SCHED_YIELD只要进程属于这种，即任何进程都可以抢占它。
实现O(1)时间片重新分配：在实时调度中，每一个cpu维护自己的一个运行队列（active array），为了实现O(1)时间的重新分配时间片，还有一个辅助的队列（expired array），前一个是运行队列，里面装着的都是等待运行的任务，当时间片结束后，调度器重新计算进程的时间片，优先级，从active中删除，加入expired队列中，当active变为空的时候，两个指向队列的指针呼唤，active取得expired的任务后继续运行，从而达到O(1)时间内完成时间片的分配。
Linux 2.6调度优先级与时间片算法
linux调度过程中调度优先级与时间片算法对象设计与描述：动态优先级的计算主要由 effect_prio() 函数完成，该函数实现相当简单，从中可见非实时进程的优先级仅决定于静态优先级（static_prio）和进程的sleep_avg 值两个因素，而实时进程的优先级实际上是在setscheduler() 中设置的（详见"调度系统的实时性能"，以下仅考虑非实时进程），且一经设定就不再改变。
unsigned long sleep_avg进程的平均等待时间，单位是纳秒（nanosecond），在0 ~ NS_MAX_SLEEP_AVG范围内。
它的实质是进程等待时间和运行时间的差值。
当进程处于等待或者睡眠状态时，该值变大；当进程运行时，该值变小。
上本次休眠时间 sleep_time 就达到了如果不是从TASK_UNINTERRUPTIBLE 休眠中被唤醒的（p->activated!=-1）sleep_avg 是进程的"平均"等待时间，recalc_task_prio() 计算了等待时间，如果不是从 TASK_UNINTERRUPTIBLE 休眠中被唤醒的（p->activated!=-1）系统引入了一个interactive_credit 的进程属性（见"改进后的task_struct"），用来表征该进程是否是交互式进程：只要interactive_credit 超过了CREDIT_LIMIT 的阀值（HIGH_CREDIT()返回真），该进程就被认为是交互式进程。
进程本次运行的时间 run_time交互式进程的 run_time 小于实际运行时间，sleep_avg 越大，则 run_time 减小得越多，因此被切换下来的进程最后计算所得的 sleep_avg 也就越大，动态优先级也随之变大。
交互式进程可以借此获得更多被执行的机会。
linux 优先级对应关系
linux 优先级对应关系Linux 优先级对应关系一、引言在Linux操作系统中，进程调度是一个重要的概念。
每个进程都有一个优先级，它决定了进程在系统中的执行顺序。
本文将详细介绍Linux中优先级的对应关系，从而帮助读者更好地理解进程调度的原理和机制。
二、进程调度的基本概念在多道程序设计环境中，操作系统需要合理分配CPU资源给各个进程，以提高系统的效率和响应速度。
进程调度就是根据一定的策略和算法，决定哪个进程能够获得CPU的使用权。
而进程的优先级则是进程调度的重要因素之一。
三、进程优先级的作用进程优先级决定了进程在系统中的执行顺序。
优先级高的进程将被优先选择执行，而优先级低的进程则会被推迟执行。
通过合理设置进程的优先级，可以提高系统的响应速度和资源利用率。
四、进程优先级的取值范围在Linux中，进程的优先级范围为-20到19，其中-20表示最高优先级，19表示最低优先级。
默认情况下，进程的优先级为0。
五、不同优先级的对应关系1. 实时进程：优先级范围为-20到19，其中-20到-1为实时进程的优先级范围，0为普通进程的默认优先级，1到19为普通进程的优先级范围。
实时进程的优先级越高，获得CPU的机会越大。
2. 静态优先级：在实时进程中，可以通过设置静态优先级来调整进程的优先级。
静态优先级的范围为1到99，其中1为最高优先级，99为最低优先级。
3. 动态优先级：动态优先级是根据进程的行为和资源使用情况动态调整的，它可以在实时进程和普通进程之间切换。
动态优先级的范围为100到139，其中100为最高优先级，139为最低优先级。
4. 时间片：时间片是指进程在获得CPU后能够使用的时间。
在Linux中，时间片是与优先级相关的，优先级越高，获得的时间片越长。
5. 进程Nice值：Nice值是一种相对优先级的表示方式，在Linux 中，它的范围为-20到19。
Nice值越小，表示进程的优先级越高。
六、优先级的调整1. 实时进程的优先级可以通过设置静态优先级进行调整。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
linux调度过程中调度优先级与时间片算法对象设计与描述：动态优先级的计算主要由 effect_prio() 函数完成，该函数实现相当简单，从中可见非实时进程的优先级仅决定于静态优先级（static_prio）和进程的sleep_avg 值两个因素，而实时进程的优先级实际上是在setscheduler() 中设置的（详见"调度系统的实时性能"，以下仅考虑非实时进程），且一经设定就不再改变。
unsigned long sleep_avg进程的平均等待时间，单位是纳秒（nanosecond），在0 ~ NS_MAX_SLEEP_AVG范围内。
它的实质是进程等待时间和运行时间的差值。
当进程处于等待或者睡眠状态时，该值变大；当进程运行时，该值变小。
上本次休眠时间 sleep_time 就达到了如果不是从TASK_UNINTERRUPTIBLE 休眠中被唤醒的（p->activated!=-1）sleep_avg 是进程的"平均"等待时间，recalc_task_prio() 计算了等待时间，如果不是从 TASK_UNINTERRUPTIBLE 休眠中被唤醒的（p->activated!=-1）系统引入了一个interactive_credit 的进程属性（见"改进后的task_struct"），用来表征该进程是否是交互式进程：只要interactive_credit 超过了CREDIT_LIMIT 的阀值（HIGH_CREDIT()返回真），该进程就被认为是交互式进程。
进程本次运行的时间 run_time交互式进程的 run_time 小于实际运行时间，sleep_avg 越大，则 run_time 减小得越多，因此被切换下来的进程最后计算所得的 sleep_avg 也就越大，动态优先级也随之变大。
交互式进程可以借此获得更多被执行的机会。
run_time 可以用系统当前时间与进程 timestamp（上一次被调度运行的时间）的差值表示，但不能超过NS_MAX_SLEEP_AVG用户进程(p->mm!=NULL)等待得越久，sleep_avg 越大，进程越容易被调度到；而运行得越久，sleep_avg 越小，进程越不容易调度到。
在 wake_up_forked_process() 中，父进程的 sleep_avg 要乘以PARENT_PENALTY/100，而子进程的sleep_avg 则乘以CHILD_PENALTY/100。
实际上PARENT_PENALTY 为100，CHILD_PENALTY 等于95，也就是说父进程的sleep_avg 不会变，而子进程从父进程处继承过来的sleep_avg 会减小5%，因此子进程最后的优先级会比父进程稍低（但子进程仍然会置于与父进程相同的就绪队列上，位置在父进程之前--也就是"前言"所说"子进程先于父进程运行"）。
一个进程结束运行时，如果它的交互程度比父进程低（sleep_avg 较小），那么核心将在sched_exit()中对其父进程的sleep_avg 进行调整，这表明sleep_avg可以表示交互度进程优先级无论什么进程静态优先级固定，实时进程动态优先级也固定利用进程平均等待时间来衡量进程的优先级，使得宏观上相同静态优先级的所有进程的等待时间和运行时间的比值趋向一致，反映了Linux 要求各进程分时共享cpu 的公平性。
另一方面，sleep_avg 还是进程交互式程度的衡量标准。
effective_prio()函数将进程的sleep_avg映射成范围是-MAX_BONUS/2 ~ MAX_BONUS/2的变量bonus，而MAX_BONUS是等于，可见sleep_avg仅能影响的优先级范围在-5 ~ 5之间。
具体的映射是由以下规则完成的：那么进程的动态优先级就等于：（当然必须在MAX_RT_PRIO和MAX_PRIO-1之间）。
可见，sleep_avg和bonus是一个线性关系。
进程的sleep_avg越大，bonus 越大，从而进程的动态优先级也就越高。
函数recalc_task_prio ()先要根据进程被唤醒前的状态（即actived）、interactive_credit等来计算进程的sleep_avginteractive_credit有两处增1的地方，都在函数recalc_task_prio()里面减少interactive_credit只有一处地方减1，在函数schedule()里面。
sleep_avg给进程带来的动态优先级上的奖励最大只有5时间片的计算：time_slice完全只与(p)->static_prio有关进程的时间片time_slice是基于进程静态优先级的，静态优先级越高（值越小），时间片就越大。
计算时间片是同过函数task_timeslice()（kernel/sched.c）来完成的。
该函数也是使用线性映射的方法，将进程优先级[MAX_RT_PRIO, MAX_PRIO-1]映射到时间片[MIN_TIMESLICE, MAX_TIMESLICE]范围内。
通过优先级来计算时间片的等式为：timeslice = MIN_TIMESLICE + ((MAX_TIMESLICE - MIN_TIMESLICE) *(MAX_PRIO-1- (p)->static_prio) / (MAX_USER_PRIO-1))effective_prio()函数返回进程p的动态优先级static int effective_prio(task_t *p){int bonus, prio;如果进程p是个实时进程，那么直接返回该实时进程的prio(实时进程的动态优先级prio不依赖于静态优先级static_prio，两者是否相等???)|----------------------------|| if (rt_task(p)) || return p->prio; ||----------------------------|计算红利bonus:|---------------------------------------------|| bonus = CURRENT_BONUS(p) - MAX_BONUS / 2; ||---------------------------------------------|根据如下公式计算该进程动态优先级prio:与static_prio，sleep_avg有关prio = max ( 100, min(static_prio - bonus + 5, 139) )|------------------------------------|| prio = p->static_prio - bonus; || if (prio < MAX_RT_PRIO) || prio = MAX_RT_PRIO; || if (prio > MAX_PRIO-1) || prio = MAX_PRIO-1; ||------------------------------------|return prio;}A:优先级优先级由两部分构成，一是静态优先级static_prio，一是动态优先级prio。
静态优先级在进程创建的时候就被赋值，并且不变（除非用系统调用改变进程的nice值）；而进程的动态优先级则是跟static_prio和sleep_avg有关。
对于实时进程的优先级在创建的时候就确定了，而且一旦确定以后就不再改变，所以下面部分仅对于非实时进程而言。
具体的计算由函数effecitve_prio()（kernel/sched.c）完成：sleep_avg函数将进程的sleep_avg映射成范围是-MAX_BONUS/2 -- MAX_BONUS/2的变量bonus，而MAX_BONUS 是等于10 ，可见sleep_avg仅能影响的优先级范围在-5 ~ 5之间。
sleep_avg和bonus是一个线性关系。
进程的sleep_avg越大，bonus越大，从而进程的动态优先级也就越高。
B:计算优先级：recalc_task_prio()来计算进程的sleep_av计算进程的动态优先级一般调用两个函数，一个是effective_prio()，一个是recalc_task_prio()。
函数recalc_task_prio ()先要根据进程被唤醒前的状态（即actived）、interactive_credit等来计算进程的sleep_avg,在最后调用effective_prio()来计算函数的动态优先级。
总的来说，有以下几种情况需要计算进程的优先级：a. 创建新进程，使用函数effective_prio()（因为此时进程尚未进行调度，没有sleep_avg和interactive_credit可言）；b. 唤醒等待进程时，使用函数recalc_task_prio ()来计算进程动态优先级。
c. 进程用完时间片以后，被重新插入到active array或者expired array的时候需要重新计算动态优先级，以便将进程插入到队列的相应位置。
此时，使用函数effective_prio()；d. 其他情况，如IDLE进程初始化等时候。
(2) 进程时间片A:时间片的计算：仅有普通进程要计算进程的时间片time_slice是基于进程静态优先级的，静态优先级越高（值越小），时间片就越大。
计算时间片是同过函数task_timeslice()（kernel/sched.c）来完成的。
该函数也是使用线性映射的方法，将进程优先级[MAX_RT_PRIO, MAX_PRIO-1]（这个优先级区间静态优先级是普通进程的）映射到时间片[MIN_TIMESLICE, MAX_TIMESLICE]范围内。
通过优先级来计算时间片的等式为：timeslice = MIN_TIMESLICE + ((MAX_TIMESLICE - MIN_TIMESLICE) *(MAX_PRIO-1- (p)->static_prio) / (MAX_USER_PRIO-1))B:计算时间片在Linux 2.6中时间片的计算是分散的，具体的计算既可以用task_timeslice()，也可以用其他方法。
a. 进程创建时，将父进程的时间片分一半给子进程，同时父进程的时间片减半。
b. 进程用完时间片以后，需要重新计算时间片，并将进程插入到相应的运行队列。