下载文档原格式
操作系统调度算法实验报告摘要：本篇实验报告旨在研究和分析不同的操作系统调度算法对系统性能的影响。
通过实验，我们对先来先服务调度算法、短作业优先调度算法和时间片轮转调度算法进行了比较和评估。
实验结果表明，不同的调度算法对系统响应时间、吞吐量和公平性等方面都有不同的影响。
一、引言操作系统的调度算法是管理计算机资源的关键部分之一。
调度算法的好坏直接影响着系统的性能和用户体验。
本实验旨在通过模拟不同的调度算法，评估其对系统的影响，以便选择最适合特定环境的调度算法。
二、实验方法本实验使用了一个模拟的操作系统调度器，通过调度器模拟不同的进程到达和执行过程。
我们选择了三种常见的调度算法进行比较和评估。
1. 先来先服务（First-Come, First-Served）调度算法先来先服务调度算法按照进程到达的先后顺序进行调度。
当一个进程到达后，它将占用处理器直到该进程执行完毕。
我们记录了每个进程的到达时间、执行时间和完成时间，并计算了系统的平均等待时间和平均周转时间。
2. 短作业优先（Shortest Job First）调度算法短作业优先调度算法按照进程执行时间的长短进行调度。
当一个进程到达后，系统会选择执行剩余执行时间最短的进程。
我们同样记录了每个进程的到达时间、执行时间和完成时间，并计算了系统的平均等待时间和平均周转时间。
3. 时间片轮转（Round Robin）调度算法时间片轮转调度算法将处理器时间分成若干个时间片，每个进程只能占用一个时间片。
当一个进程用完一个时间片后，它排到队列的末尾等待下一个时间片。
我们选择了不同的时间片长度，并观察了系统的响应时间和吞吐量。
三、实验结果与分析我们通过多组实验数据对不同的调度算法进行了评估。
以下是实验结果的分析：1. 先来先服务调度算法根据实验数据，我们发现先来先服务调度算法对长作业具有较高的等待时间和周转时间。
这是因为当一个长作业到达后，其他短作业需要等待该作业执行完毕才能获得处理器资源。
北大操作系统高级课程陈向群作业线程调度实习报告一、引言本报告旨在对北大操作系统高级课程中陈向群老师布置的线程调度实习进行总结和反思。
通过本次实习，我深入了解了操作系统中线程调度的原理和技术，并在实践中掌握了相关算法和方法。
二、实习内容1. 实践环境本次实践使用了一台基于Linux系统的虚拟机。
在虚拟机中，我编写了一个简单的多线程应用程序，并通过调整线程调度参数来观察不同调度策略下的线程行为与性能。
2. 理论知识回顾在开始实践之前，我对线程调度的理论知识进行了回顾。
线程调度是操作系统中相当重要的一项功能，其主要目的是合理地分配CPU时间片给不同的线程，以实现最大化系统的性能和资源利用率。
3. 实践过程我首先编写了一个简单的多线程应用程序，其中包含了几个线程并发执行的任务。
然后，我通过修改代码中的调度策略和参数来观察线程的执行顺序和总运行时间。
4. 实践结果和分析通过对不同线程调度策略的尝试，我观察到了不同线程调度策略下线程行为和系统性能的差异。
比如，在FIFO调度策略下，线程按照它们创建的先后次序执行，而在RR（Round-Robin）调度策略下，线程按照时间片的轮转方式进行执行。
5. 总结与反思通过实践，我深刻理解了线程调度的重要性和影响因素。
合理的线程调度策略能够最大化地发挥系统性能，提高计算资源的利用率。
在实践过程中，我也遇到了一些问题和困难，如如何选择最合适的线程调度策略以及如何调整合适的调度参数。
这些问题需要深入研究和探索。
三、实践总结通过这次线程调度实习,我收获了很多。
首先，我深入了解了操作系统中线程调度的原理和技术。
其次，我掌握了一些常见的线程调度算法和方法，并能够通过实践来判断和选择适当的调度策略。
此外，我还掌握了一些调整调度策略和参数的技巧，并能够通过观察线程行为和系统性能的变化来验证和分析调度效果。
然而，这次实习也暴露出了我一些不足之处。
首先，我对于一些现代高级线程调度算法和技术还不够了解，需要进一步学习和研究。
操作系统实验报告作业调度操作系统实验报告：作业调度引言作业调度是操作系统中的重要部分，它负责管理和调度系统中的各种作业，以最大化系统资源的利用率和提高作业的执行效率。
在本次实验中，我们将探讨作业调度的基本原理和实现方法，并通过实验验证其效果。
实验目的本次实验的主要目的是通过实际操作，了解作业调度的基本原理和实现方法，掌握作业调度的相关算法，并通过实验验证其有效性。
实验内容1. 实现作业调度的基本算法在本次实验中，我们将实现作业调度的基本算法，包括先来先服务（FCFS）、最短作业优先（SJF）、优先级调度（Priority Scheduling）和多级反馈队列调度（Multilevel Feedback Queue Scheduling）等。
通过编写代码，模拟这些算法的执行过程，并观察它们的效果。
2. 实验验证我们将设计一些测试用例，通过模拟作业的执行过程，分别使用不同的作业调度算法，并比较它们的执行效果。
通过实验验证，我们将得出不同算法的优劣势，并分析其适用场景。
实验结果经过实验验证，我们得出以下结论：1. 先来先服务（FCFS）算法适用于作业执行时间相对均匀的情况，但可能会导致平均等待时间较长。
2. 最短作业优先（SJF）算法能够最大程度地减少平均等待时间，但可能会出现作业饥饿现象。
3. 优先级调度（Priority Scheduling）算法能够根据作业的优先级进行调度，适用于有明确优先级需求的情况。
4. 多级反馈队列调度（Multilevel Feedback Queue Scheduling）算法能够根据作业的执行情况动态调整优先级，适用于各种类型的作业。
结论作业调度是操作系统中的重要组成部分，不同的作业调度算法适用于不同的场景。
通过本次实验，我们深入了解了作业调度的基本原理和实现方法，掌握了不同算法的优劣势，并通过实验验证了它们的有效性。
这将对我们进一步深入学习操作系统和提高系统性能有着重要的意义。
虚拟内存管理实习报告目录内容一：总体概述 (3)内容二：任务完成情况 (3)任务完成列表（Y/N） (3)具体Exercise的完成情况 (3)内容三：遇到的困难以及解决方法 (11)内容四：收获及感想 (11)内容五：对课程的意见和建议 (11)内容六：参考文献 (11)内容一：总体概述本次lab主要是针对操作系统内存管理的学习，内存管理主要有固定分区、可变分区、页式和段式管理。
现代操作系统主要采用页式内存管理，它把用户程序地址空间划分成大小相等的部分，称为页。
内存空间按页的大小划分为大小相等的区域，称为内存块（物理页面，页框，页帧）。
以页为单位进行分配，逻辑上相邻的页，物理上不一定相邻。
虚拟内存的基本思想：每个程序拥有自己的地址空间，这个空间被分割成多个块，每一块称作一页或者页面，每一页有连续的地址范围。
这些页被映射到物理内存，但并不是所有页都必须在内存中才能运行。
当程序引用到一部分在物理内存中的地址空间时，由硬件立即执行必要的映射。
当程序引导到一部分不在物理内存中德的地址空间时，由操作系统负责将缺失的部分装入屋里内存并重新执行失效的指令。
内容二：任务完成情况任务完成列表（Y/N）Exercise1 Exercise2 Exercise3 Exercise4 Exercise5 Exercise6 Exercise7 Challange 完成情况Y Y Y Y Y Y N N具体Exercise的完成情况一、TLB异常处理目前，Nachos系统对于内存的管理是基于软件模拟的TLB机制。
其工作原理、异常处理、替换算法等方面，与分页式内存管理非常相像。
Exercise 1 源代码阅读Ø阅读code/userprog/，着重理解nachos执行用户程序的过程，以及该过程中与内存管理相关的要点。
Ø阅读code/machine目录下的machine.h(cc)，translate.h(cc)文件和code/userprog目录下的exception.h(cc)，理解当前Nachos系统所采用的TLB机制和地址转换机制。
实验二、作业调度实验实验项目名称：作业调度实验实验项目性质：验证性实验所属课程名称：《操作系统》实验计划学时：2 学时、实验目的本实验要求学生模拟作业调度的实现，用高级语言编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解。
、实验内容和要求为单道批处理系统设计一个作业调度程序(1) 、编写并调试一个单道处理系统的作业调度模拟程序。
(2) 、作业调度算法：分别采用先来先服务( FCFS)，最短作业优先( SJF)、响应比高者优先( HRN )的调度算法。
(3) 、由于在单道批处理系统中，作业一投入运行，它就占有计算机的一切资源直到作业完成为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CPU 时限等因素。
(4) 、每个作业由一个作业控制块JCB 表示，JCB 可以包含如下信息：作业名、提交时间、所需的运行时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W(Wait) 、运行R(Run)和完成F(Finish)三种状态之一。
每个作业的最初状态总是等待W 。
(5) 、对每种调度算法都要求打印每个作业开始运行时刻、完成时刻、周转时间、带权周转时间，以及这组作业的平均周转时间及带权平均周转时间，并比较各种算法的优缺点。
三、实验设计方案及原理假设在单道批处理环境下有四个作业JOB1、JOB2、JOB3、JOB4，已知它们进入系统的时间、估计运行时间。
分别采用先来先服务(FCFS)，最短作业优先( SJF)、响应比高者优先( HRN )的调度算法，计算出作业的平均周转时间和带权的平均周转时间。
作业i 的周转时间：Ti= 运行结束时间-到达时间作业的平均周转时间：T=作业i 的带权周转时间：Wi= 周转时间/所需运行时间作业的平均带权周转时间：W= 先来先服务调度算法( FCFS)：每次调度都是从后备作业队列中，选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。
系统调用实习报告目录内容一：总体概述 (3)内容二：任务完成情况 (3)任务完成列表（Y/N） (3)具体Exercise的完成情况 (3)内容三：遇到的困难以及解决方法 (6)内容四：收获及感想 (6)内容五：对课程的意见和建议 (7)内容六：参考文献 (7)内容一：总体概述通过这次实习，更加深入地了解了Nachos 系统调用的实现。
巩固了原理课上学习的关于Linux 系统调用的实现细节。
这次试验也主要是系统调用的相关实现涉及了syscall.h，，start.s 的原理部分和相关调用部分的再实现。
内容二：任务完成情况任务完成列表（Y/N）Exercise1 Exercise2 Exercise3 Exercise4 Exercise5 完成情况Y Y Y Y Y具体Exercise的完成情况一、理解Nachos系统调用Exercise 1 源代码阅读阅读与系统调用相关的源代码，理解系统调用的实现原理。
code/userprog/syscall.h解答：该文件是nachos 系统调用的头文件，里面声明了一些nachos 的内核操作，可以被用户程序通过syscall 调用，在用户程序和内核文件中都需包含本文件，其中包含了Halt,Exit,Exec,Join,Create,Open,Read,Write,Close,Fork,Yield 调用方法的声明。
code/userprog/解答：Exception.h 和 是专门用来检测和处理异常信息的类，原始的nachos给出了syscall 异常的处理方式，并通过ExceptionHandler对各种异常进行处理。
code/test/start.s解答：start.s 文件中用汇编语言协助用户程序在nachos 中运行，以避免使用完整的c 库，我们定义了用户程序所需要的东西以便进行系统调用。
二、文件系统相关的系统调用Exercise 2系统调用实现类比Halt的实现，完成与文件系统相关的系统调用：Create, Open，Close，Write，Read。
实验二作业调度实验题目1、编写并调试一个单道解决系统的作业等待模拟程序。
作业调度算法:分别采用先来先服务（FCFS）,最短作业优先（SJF）的调度算法。
（1 ）先来先服务算法:按照作业提交给系统的先后顺序来挑选作业，先提交的先被挑选。
（2）最短作业优先算法：是以进入系统的作业所提出的“执行时间”为标准,总是优先选取执行时间最短的作业。
二.实验目的：本实验规定用高级语言（C语言实验环境）编写和调试一个或多个作业调度的模拟程序，了解作业调度在操作系统中的作用，以加深对作业调度算法的理解三.实验过程〈一〉单道解决系统作业调度1）单道解决程序作业调度实验的源程序:zuoye.c 执行程序：zu o y e.exe2）实验分析：1、由于在单道批解决系统中，作业一投入运营，它就占有计算机的一切资源直到作业完毕为止，因此调度作业时不必考虑它所需要的资源是否得到满足，它所占用的CP U时限等因素。
2、每个作业由一个作业控制块JCB表达,JCB可以包含如下信息:作业名、提交时间、所需的运营时间、所需的资源、作业状态、链指针等等。
作业的状态可以是等待W（Wait）、运营R（Run）和完毕F（Finish）三种状态之一。
每个作业的最初状态else i f (p->n e e d time<min->need t ime) m in=p； p= p ->next；( while (p!=NULL);i f (iden) {i—；/ / pr i n tf ("\nt i m e =%d: \ t no JCB sub mib.. . wait . . . t ime);tim e s++；i f ( times> 10 0) {prin t f("\nru n t ime i s too Ion g . .. error z，) ;g etc h () ； ))e 1 s e{ru n ning(m i n, m) ；//调用running ()函数}} //forf i na 1 (); 〃调用r u nn i ng()函数)voi d fefs (int m)〃先来先服务算法(int i, iden;syst e m ("cl s ");i ni t a 1 ();f or(i=0;i<n;i++)(p= r ea d y； i d en=l;do{if (p-> s tate= = , W* & &p ->reach t i me<=t i mes) i d e n=0：i f (i d e n )p= p -> n ext;}while(p!=NULL&&iden);if (i d on){i——；prin tf(〃\ n没有满足规定的进程，需等待”)；t imes++;i f (time s >1 0 0 ) {prin t f ("\n 时间过长")；getch () ;})e 1 se{runn i ng(p, m); 〃调用r u nn i n g ()函数))final () ;//调用ru n n i n g ()函数}void muneO{int m;s y s tem (〃 c 1 s〃)；p r i n t f (z/\ n\n\t\t *** 火 * ****** * ***** * ***** *** *** * *** * **** ***** **\ t \ t\n ");P rintf ('\t \ t \ t\t 作业调度演示\ n ")；pr i ntf( " \t\t^ ***** * * *** * *** * ******** * * **** * ******** * * *** * \t\P r intf(*\n\n\n\t\ t \tl.先来先服务算法.;pr i nt f ("\n\t\ t \ t2.最短作业优先算法.;printfC\n\ t \ t \t3.响应比高者优先算法");prin t f ( ° \0.退出程序.;P rintfC \n\n\t \t\ t \t 选择所要操作:");s c anf (*%d*, &m);sw i tc h (m)(c ase 1:f c f s (m);getchO ；s y stem("c 1 s");mune();brea k ;c a se 2 :sjf (m):getch ();system ( " cis*)；mune ();break；case 3 :hr n (m);g e t c h ();sys t em("cls");mune ()；br e a k ；case 0:system ("cis");break;d e f a u 1 t :pr intf(〃选择错误，重新选择getchO ;system ("c Is");muneO ;))main ()//主函数(i niz e ();muneO ;)5)调试结果：i.选择操作的界面程课件'计算机操作系统联作系统实验八作业调度\zuoye.exe ，作业调度演示.先来先服务算法.1 .最短企业优先算法.2 .响应居意者优先萱法 4战出程序.选择所要操作:2.输入操作初始信息:c 「E:\课程课件'计算机》3 .先来先服务算法作业调度结果：（调度顺序：a -> b ->c->d->e ）输入作业数：5输入作业数：5太人作业名:a7、侬、|到达时间:0要运行的时间：4 必法崎松时间其要运行的时间：3植入作业名:c 作业默认到达时间:2 曲人作批要运行的时间;5 植入作业名:d 伟业默认到达时间：3 曲入作要运行的时间;2 检入作业名:e 伟业默认到达时间;4 输入作业要运行的时间;4作业证在运行，估计其运行情况: 开始运宜时刻：。
同步机制实习报告目录内容一：总体概述 (3)内容二：任务完成情况 (3)任务完成列表（Y/N） (3)具体Exercise的完成情况 (3)内容三：遇到的困难以及解决方法 (13)内容四：收获及感想 (13)内容五：对课程的意见和建议 (13)内容六：参考文献 (13)内容一：总体概述本次lab是对进程的同步和互斥的相关调用和实验。
进程的同步和互斥是在多道程序并发时由于程序执行的间断性而导致了执行结果的不确定性，引出来的概念。
同步关系就是进程之间执行的时候有先后顺序而产生的一种关系，互斥关系是程序共享临界资源的时候必须互斥的使用而产生的一种关系。
同步和互斥有很多种解决方法，nachos提供了使用P、V操作来控制同步和互斥。
内容二：任务完成情况任务完成列表（Y/N）Exercise1 Exercise2 Exercise3 Exercise4完成情况Y Y Y Y具体Exercise的完成情况Exercise1调研调研Linux中实现的同步机制解答：原子操作原子操作是不可分割的，在执行完毕不会被任何其它任务或事件中断。
在单处理器系统（UniProcessor）中，能够在单条指令中完成的操作都可以认为是"原子操作"，因为中断只能发生于指令之间。
这也是某些CPU指令系统中引入了 test_and_set、test_and_clear等指令用于临界资源互斥的原因。
但是，在对称多处理器（Symetric Multi-Processor）结构中就不同了，由于系统中有多个处理器在独立地运行，即使能在单条指令中完成的操作也有可能受到干扰。
我们以 decl（递减指令）为例，这是一个典型的"读－改－写"过程，涉及两次内存访问。
自旋锁自旋锁：单处理器非抢占式内核和对称多处理器或抢占式内核Linux 2.4.x及以前的版本都是非抢占式内核方式，如果编译成单处理器系统，在同一时间只有一个进程在执行，除非它自己放弃，不然只有通过"中断"才能中断其执行。
线程机制实习报告目录内容一：总体概述 (3)内容二：任务完成情况 (3)任务完成列表（Y/N） (3)具体Exercise的完成情况 (3)内容三：遇到的困难以及解决方法 (7)内容四：收获及感想 (7)内容五：对课程的意见和建议 (7)内容六：参考文献 (8)内容一：总体概述本次lab主要是对线程机制的学习和理解。
首先，进程控制块（PCB）是进程存在的标志，系统利用PCB来控制和管理进程，所以PCB是系统感知进程存在的唯一标志。
用它来记录进程的外部特征，描述进程的运动变化过程。
Exercise1通过对不同系统的进程控制块的调研学习进程控制块在不同系统中的实现方式。
内容二：任务完成情况任务完成列表（Y/N）Exercise1 Exercise2 Exercise3 Exercise4完成情况Y Y Y Y具体Exercise的完成情况Exercise1调研调研Linux或Windows中进程控制块（PCB）的基本实现方式，理解与Nachos的异同。
解答：Linux的进程控制块为一个由结构task_struct所定义的数据结构，task_struct存放在/include/linux/sched.h中，其中包括管理进程所需的各种信息。
Linux系统的所有进程控制块组织成结构数组形式。
早期的Linux版本是多可同时运行进程的个数由NR_TASK(缺省值为512)规定,NR_TASK即为PCB结果数组的长度。
近期版本中的PCB组成一个环形结构，系统中实际存在的进程数由其定义的全局变量nr_task来动态记录。
结构数组：struct task_struct *task[NR_TASK]={&init_task}来记录指向各PCB的指针，该指针数组定义于/kernel/sched.c中。
在创建一个新进程时，系统在内存中申请一个空的task_struct区，即空闲PCB块，并填入所需信息。
同时将指向该结构的指针填入到task[]数组中。
操作系统原理实训课程学习总结进程调度算法的实验验证与优化在操作系统原理实训课程中，我深入学习了进程调度算法，并进行了实验验证与优化。
本文将对我在这门课程中的学习经历进行总结，并重点介绍我在进程调度算法实验方面的实践与优化。
一、学习经历总结在操作系统原理实训课程中，我通过理论学习和实践操作，全面了解了操作系统的基本概念和原理。
我通过学习教材、参与课堂讨论和实验操作，逐渐掌握了进程调度算法的相关知识和应用。
通过对课程的学习，我清楚地认识到进程调度在操作系统中的重要性。
合理的进程调度算法可以提高系统的运行效率和资源利用率，同时保证各个进程的公平性和优先级。
在学习的过程中，我学会了不同的进程调度算法，并了解了它们的特点和适用场景。
二、实验验证与优化为了深入理解和掌握进程调度算法，我进行了一系列的实验验证和优化。
以下是我进行的几个主要实验：1. 实验一：先来先服务（FCFS）调度算法通过模拟多个进程同时到达一个处理器，我验证了先来先服务调度算法的运行情况。
根据实验结果，我发现在进程的运行时间差异较大时，先来先服务调度算法可能会导致平均等待时间较长的问题。
为了优化这一问题，我尝试了引入响应比和时间片轮转等策略来改善进程调度效果。
2. 实验二：短作业优先（SJF）调度算法通过模拟多个进程以不同的作业时间到达处理器，我验证了短作业优先调度算法的运行情况。
实验结果表明，在作业时间相差较大时，短作业优先调度算法能够有效减少平均等待时间。
但是，当出现长作业阻塞短作业的情况时，短作业优先调度算法可能产生饥饿现象。
因此，在优化中，我考虑了引入抢占式调度策略以降低长作业优先级，解决饥饿问题。
3. 实验三：优先级调度算法通过设置不同优先级的进程，我验证了优先级调度算法的运行情况。
实验结果表明，优先级调度算法能够有效地保证高优先级进程的运行权。
但是，在进程优先级设置不当或者优先级反转等情况下，该算法可能产生不公平性问题。
为了解决这个问题，我优化了进程的优先级计算方法，采用动态调整的方式来提高调度算法的公平性。
线程调度实习报告目录内容一：总体概述 (3)内容二：任务完成情况 (3)任务完成列表（Y/N） (3)具体Exercise的完成情况 (3)内容三：遇到的困难以及解决方法 (8)内容四：收获及感想 (9)内容五：对课程的意见和建议 (9)内容六：参考文献 (9)内容一：总体概述本次lab主要是对线程调度的学习和理解。
当计算机系统是多道程序设计系统时，通常就会有多个进程或或线程同时竞争CPU。
只要有两个或更多的进程处于就绪态，这种情况就会发生，那么就必须选择下一个要运行的进程。
在操作系统中，完成选择工作的这一部分称为调度程序，该程序使用的算法称为调度算法。
进程调度策略的选择对整个系统性能有至关重要的影响，一个好的调度算法应该考虑很多方面：公平、有效、响应时间、周转时间、系统吞吐量等等。
但这些因素之间又是相互矛盾的，最终的取舍根据系统要达到的目标而定,同时我们也可以看出多进程的管理是～种非常复杂的并发程序设计．每个进程的状态不仅由其自身决定，而且还要受诸多外在因素的影响．而在此基础上的进程调度，为了保证操作系统的稳定性、提高效率和增加灵活性，还必须采用很多方法，这些都是值得我们去研究和探讨的。
本次实验针对Nachos系统的代码的阅读和修改，了解Nachos系统中线程调度在代码中如何实现，以及在其上扩展线程调度算法，实现基于优先级的抢占式调度算法。
内容二：任务完成情况任务完成列表（Y/N）Exercise1 Exercise2 Exercise3完成情况Y Y Y具体Exercise的完成情况Exercise1调研了解Linux或Windows中采用的进程/线程调度算法。
解答：Linux 的调度算法演化伴随着其内核版本的更迭，具有代表性的版本以此为：2.4，2.6,以及最近几年频繁更替的版本：3.5,3.6,3.7,3.8，其中3.8 是最新的稳定版本。
下面就其调度机制的演化进行论述。
在 2.4 版本的内核之前，当很多任务都处于活动状态时，调度器有很明显的限制。
这是由于调度器是使用一个复杂度为O(n) 的算法实现的。
在这种调度器中，调度任务所花费的时间是一个系统中任务个数的函数。
换而言之，活动的任务越多，调度任务所花费的时间越长。
在任务负载非常重时，处理器会因调度消耗掉大量的时间，用于任务本身的时间就非常少了。
因此，这个算法缺乏可伸缩性。
在对称多处理系统（SMP）中，2.4 版本之前的调度器对所有的处理器都使用一个运行队列。
具体来说，linux2.4 采用的是遍历可运行队列，动态优先级调度算法，其算法的复杂度在O(n)级别上，而linux2.6 采用的是双队列调度算法，一个是活跃的优先级数组，另一个是过期的优先级数组，这一思想在最新版的3.8 上面仍然继续沿用。
Linux 的调度将所有进程分为三类，一是交互式进程，他们有大量的人机交互，不断地处于睡眠状态，等待用户输入。
此类进程对系统响应时间要求比较高，否则用户会感觉系统反应迟缓。
第二个是批处理进程，他们不需要人机交互，在后台运行大量的运算。
此类进程需要占用大量的系统资源，但是能够忍受响应延迟。
第三个是实时进程，他们对调度延迟的要求最高，这些进程往往执行非常重要的操作，要求立即响应并执行。
这类程序不能容忍长时间的调度延迟。
在2.4 的调度策略使用的是Pick-Next 算法：对Runqueue 中所有进程的优先级进行依次进行比较，选择最高优先级的进程作为下一个被调度的进程。
(Runqueue 是Linux 内核中保存所有就绪进程的队列)。
旧版的进程时间片计算：每个进程被创建时都被赋予一个时间片。
时钟中断递减当前运行进程的时间片，当进程的时间片被用完时，它必须等待重新赋予时间片才能有机会运行。
Linux2.4 调度器保证只有当所有RUNNING 进程的时间片都被用完之后，才对所有进程重新分配时间片。
这段时间被称为一个epoch。
这种设计保证了每个进程都有机会得到执行。
旧版的进程优先级计算：普通进程的优先级主要由进程描述符中的Counter 字段决定(还要加上nice 设定的静态优先级)。
当所有RUNNING进程的时间片被用完之后，调度器将重新计算所有普通进程的Counter 值（不仅包括RUNNING 进程，也包括睡眠进程）。
处于睡眠状态的进程的Counter 本来就没有用完，在重新计算时，他们的Counter 值会加上这些原来未用完的部分，从而提高了它们的优先级。
实时进程：实时进程的优先级是静态设定的，而且始终大于普通进程的优先级。
因此只有当Runqueue 中没有实时进程的情况下，普通进程才能够获得调度。
实时进程的时间片被用完时，重新分配时间片，并重新插入Runqueue 中。
实时进程调度策略：SCHED_FIFO 和SCHED_RR。
FIFO 采用先进先出的策略，对于所有相同优先级的进程，最先进入Runqueue 的进程总能优先获得调度；Round Robin 采用更加公平的轮转策略，使得相同优先级的实时进程能够轮流获得调度。
而在 2.6 版本的调度策略是基于动态抢占的，支持负载均衡，并以恒定的速度进行O(1)，它解决了2.6 之前调度器中三个主要问题（O(n)、SMP 调度、实时性）。
调度器为每一个CPU 维护了两个进程队列数组：active 数组和expire数组。
数组中的元素保存某一优先级的进程队列指针。
系统一共有140 个不同的优先级，因此这两个数组大小都是140（1-99 为实时任务）。
当需要选择当前最高优先级的进程时，2.6 调度器不用遍历整个Runqueue，而是直接从active 数组中选择当前最高优先级队列中的第一个进程。
普通进程时间片计算：每次时钟tick 中断中，进程的时间片(time_slice)被减一。
当time_slice 为0 时，调度器判断当前进程的类型（交互式进程满足Dynamic priority ≤3 x staticpriority /4 + 28），如果是交互式进程或者实时进程，则重置其时间片并重新插入active 数组。
如果不是交互式进程则从active 数组中移到expired 数组。
这样实时进程和交互式进程就总能优先获得CPU。
然而这些进程不能始终留在active 数组中，否则进入expire 数组的进程就会产生饥饿现象。
当进程已经占用CPU 时间超过一个固定值后，即使它是实时进程或者交互式进程也会被移到expire 数组中。
普通进程优先级计算：dynamic priority = max(100, min(staticpriority – bonus + 5, 139))。
其中bonus 取决于进程的平均睡眠时间。
平均睡眠时间越长，其bonus 越大，从而得到更高的优先级（提高了交互式进程的优先级）。
实时进程：实时进程的优先级由sys_sched_setschedule()设置。
该值不会动态修改，而且总是比普通进程的优先级高。
实时进程的时间片被用完时，重新分配时间片，并重新插入Active 队列尾部。
Ingo Molnar 从RSDL/SD 中吸取了完全公平的思想，在Linux Kernel2.6.23 引入CFS 调度器。
按照作者的说法：“CFS 百分之八十的工作可以用一句话概括：CFS 在真实的硬件上模拟了完全理想的多任务处理器”。
在“完全理想的多任务处理器”下，每个进程都能同时获得CPU 的执行时间。
当系统中有两个进程时，CPU 的计算时间被分成两份，每个进程获得50%。
然而在实际的硬件上，当一个进程占用CPU 时，其它进程就必须等待。
这就产生了不公平。
所以CFS 将惩罚当前进程，使其它进程能够在下次调度时尽可能取代当前进程。
CFS 使用红黑树选取下一个被调度进程。
所有状态为RUNABLE 的进程都被插入红黑树。
在每个调度点，CFS 调度器都会选择红黑树的最左边的叶子节点作为下一个将获得cpu 的进程（该读取操作的时间复杂度是O(LgN)）。
如果在调度时当前进程不再是红黑树的最左边的叶子节点，就会被抢占。
Windows 中的每一个进程都是EPROCESS 结构体。
此结构体中除了进程的属性之外还引用了其它一些与实现进程紧密相关的结构体。
例如，每个进程都有一个或几个线程, 线程在系统中就是ETHREAD 结构体。
简要描述一下存在于这个结构体中的主要的信息, 这些信息都是由对内核函数的研究而得知的。
首先，结构体中有KPROCESS 结构体, 这个结构体中又有指向这些进程的内核线程(KTHREAD) 链表的指针( 分配地址空间), 基优先级, 在内核模式或是用户模式执行进程的线程的时间, 处理器affinity( 掩码，定义了哪个处理器能执行进程的线程) ，时间片值。
在ETHREAD 结构体中还存在着这样的信息: 进程ID 、父进程ID 、进程映象名。
在EPROCESS 结构体中还有指向PEB 的指针。
ETHREAD 结构体还包含有创建时间和退出时间、进程ID 和指向EPROCESS 的指针, 启动地址，I/O 请求链表和KTHREAD 结构体。
在KTHREAD 中包含有以下信息: 内核模式和用户模式线程的创建时间，指向内核堆栈基址和顶点的指针、指向服务表的指针、基优先级与当前优先级、指向APC的指针和指向T E B 的指针。
KTHREAD 中包含有许多其它的数据, 通过观察这些数据可以分析出KTHREAD 的结构。
通过遍历KPROCESS 结构体中的ETHREAD, 找到系统中当前所有的KTHREAD 结构, 这个结构中的偏移量为0x124处的Affinity 域(WindowsXPsp3) 即为设置CPU 亲缘性掩码的内存地址。
Windows 实现了一个优先驱动的，抢先式的调度系统——具有最高优先级的可运行线程总是运行，而该线程可能仅限于在允许它运行的处理器上运行，这种现象称为处理器亲和性，在默认的情况下，线程可以在任何一个空闲的处理器上运行，但是，你可以使用windows 调度函数，或者在映像头部设置一个亲和性掩码来改变处理器亲和性。
在此重点解释CPU 亲缘性的概念,CPU 亲缘性就是指在系统中能够将一个或多个进程或线程绑定到一个或多个处理器上运行, 这是期待已久的特性。
也就是说“: 在1 号处理器上一直运行该程序”或者是“在所有的处理器上运行这些程序，而不是在0 号处理器上运行”。
然后, 调度器将遵循该规则，程序仅仅运行在允许的处理器上。
Windows 的进程调度代码是在它的System 进程下的，所以它不属于任何用户进程上下文。
调度代码在适当的时机会切换进程上下文, 这里的切换进程上下文是指进程环境的切换, 包括内存中的可执行程序, 提供程序运行的各种资源. 进程拥有虚拟的地址空间, 可执行代码, 数据, 对象句柄集, 环境变量, 基础优先级, 以及最大最小工作集等的切换。
