北大操作系统高级课程-陈向群作业-线程调度实习报告
操作系统调度算法实验报告
操作系统调度算法实验报告摘要：本篇实验报告旨在研究和分析不同的操作系统调度算法对系统性能的影响。
通过实验，我们对先来先服务调度算法、短作业优先调度算法和时间片轮转调度算法进行了比较和评估。
实验结果表明，不同的调度算法对系统响应时间、吞吐量和公平性等方面都有不同的影响。
一、引言操作系统的调度算法是管理计算机资源的关键部分之一。
调度算法的好坏直接影响着系统的性能和用户体验。
本实验旨在通过模拟不同的调度算法，评估其对系统的影响，以便选择最适合特定环境的调度算法。
二、实验方法本实验使用了一个模拟的操作系统调度器，通过调度器模拟不同的进程到达和执行过程。
我们选择了三种常见的调度算法进行比较和评估。
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。
2023年操作系统作业调度实验报告
实验二作业调度实验题目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. 实验三：优先级调度算法通过设置不同优先级的进程，我验证了优先级调度算法的运行情况。
实验结果表明，优先级调度算法能够有效地保证高优先级进程的运行权。
但是，在进程优先级设置不当或者优先级反转等情况下，该算法可能产生不公平性问题。
为了解决这个问题，我优化了进程的优先级计算方法，采用动态调整的方式来提高调度算法的公平性。
操作系统实验报告作业调度
操作系统实验报告作业调度操作系统实验报告：作业调度引言：操作系统是计算机系统中最核心的软件之一，它负责管理计算机的资源，为用户提供良好的使用环境。
在操作系统中，作业调度是非常重要的一部分，它决定了计算机如何合理地分配和调度各个作业的执行顺序，以提高计算机的效率和性能。
本实验报告将介绍作业调度的概念、调度算法以及实验结果。
一、作业调度的概念作业调度是指根据一定的策略和算法，将就绪队列中的作业按照一定的顺序分配给处理器，使得计算机系统能够充分利用资源，提高系统的吞吐量和响应时间。
作业调度的目标是实现公平性、高效性和平衡性。
二、作业调度的算法1. 先来先服务（FCFS）调度算法FCFS调度算法是最简单的调度算法之一，它按照作业的到达顺序进行调度，先到达的作业先执行。
这种算法的优点是简单易实现，但是可能会导致长作业等待时间过长，造成资源浪费。
2. 最短作业优先（SJF）调度算法SJF调度算法是根据作业的执行时间来进行调度，执行时间短的作业先执行。
这种算法能够最大程度地减少平均等待时间，提高系统的响应速度，但是可能会导致长作业长时间等待。
3. 优先级调度算法优先级调度算法是根据作业的优先级来进行调度，优先级高的作业先执行。
这种算法可以根据不同的需求设置不同的优先级，但是可能会导致低优先级的作业长时间等待。
4. 时间片轮转调度算法时间片轮转调度算法是将处理器的执行时间划分为多个时间片，每个作业在一个时间片内执行，时间片用完后，将处理器分配给下一个作业。
这种算法可以实现公平性，但是可能会导致长作业等待时间过长。
三、实验结果与分析在本次实验中，我们使用了不同的作业调度算法，并对其进行了性能测试。
测试结果显示，FCFS算法在平均等待时间方面表现较差，而SJF算法和优先级调度算法在平均等待时间方面表现较好。
时间片轮转调度算法能够实现公平性，但是可能会导致长作业等待时间过长。
结论：作业调度是操作系统中的重要组成部分，合理的作业调度算法能够提高计算机系统的效率和性能。
操作系统实验报告-作业调度
作业调度一、实验目的1、对作业调度的相关内容作进一步的理解。
2、明白作业调度的主要任务。
3、通过编程掌握作业调度的主要算法。
二、实验内容及要求1、对于给定的一组作业, 给出其到达时间和运行时间，例如下表所示：作业名 A B C D E F到达时间0 2 5 5 12 15服务时间 6 50 20 10 40 82、分别用先来先服务算法、短作业优先和响应比高者优先三种算法给出作业的调度顺序。
3、计算每一种算法的平均周转时间及平均带权周转时间并比较不同算法的优劣。
三、主要算法流程图开始响应比高者优先短作业优先先来先服务算法生成调度顺序队列计算平均周转时间及平均带权周转时间结束退出系统YN四、测试数据及运行结果测试数据workA={'作业名':'A','到达时间':0,'服务时间':6} workB={'作业名':'B','到达时间':2,'服务时间':50} workC={'作业名':'C','到达时间':5,'服务时间':20} workD={'作业名':'D','到达时间':5,'服务时间':10} workE={'作业名':'E','到达时间':12,'服务时间':40} workF={'作业名':'F','到达时间':15,'服务时间':8}运行结果先来先服务算法调度顺序:['A', 'B', 'C', 'D', 'E', 'F'] 周转时间:74.1666666667 带权周转时间:4.83333333333短作业优先算法调度顺序:['A', 'D', 'F', 'C', 'E', 'B']周转时间:44.8333333333带权周转时间:1.166********响应比高者优先算法调度顺序:['A', 'D', 'F', 'E', 'C', 'B']周转时间:48.1666666667带权周转时间:1.5五、代码#encoding=gbkworkA={'作业名':'A','到达时间':0,'服务时间':6,'结束时间':0,'周转时间':0,'带权周转时间':0}workB={'作业名':'B','到达时间':2,'服务时间':50}workC={'作业名':'C','到达时间':5,'服务时间':20}workD={'作业名':'D','到达时间':5,'服务时间':10}workE={'作业名':'E','到达时间':12,'服务时间':40}workF={'作业名':'F','到达时间':15,'服务时间':8}list1=[workB,workA,workC,workD,workE,workF]list2=[workB,workA,workC,workD,workE,workF]list3=[workB,workA,workC,workD,workE,workF]#先来先服务算法def fcfs(list):resultlist = sorted(list, key=lambda s: s['到达时间'])return resultlist#短作业优先算法def sjf(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:listdd.append(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: s['服务时间'])resultlist.append(li[0])list.remove(li[0])ctime+=li[0]['服务时间']listdd=[]return resultlist#响应比高者优先算法def hrrn(list):time=0resultlist=[]for work1 in list:time+=work1['服务时间']listdd=[]ctime=0for i in range(time):for work2 in list:if work2['到达时间']<=ctime:work2['等待时间']=ctime-work2['到达时间']listdd.append(work2)if len(listdd)!=0:li = sorted(listdd, key=lambda s: (s['等待时间']+s['服务时间'])/s['服务时间'])resultlist.append(li[-1])list.remove(li[-1])ctime+=li[-1]['服务时间']listdd=[]return resultlist#调度顺序def shunxu(resultlist,miaoshu):print(miaoshu)ddsx=[]for work in resultlist:for d,x in work.items():if d.decode('gb2312')==u'作业名':ddsx.append(x)#print d.decode('gb2312')+":"+str(x) print(u'调度顺序:'+str(ddsx))turnaroundTime(resultlist)#平均周转时间及平均带权周转时间def turnaroundTime(resultlist):time=0for work in resultlist:work['结束时间']=work['服务时间']+timetime=work['结束时间']work['周转时间']=work['结束时间']-work['到达时间']work['带权周转时间']=work['周转时间'] / work['服务时间'] zzsj=0dqzzsj=0for work in resultlist:zzsj+=work['周转时间']dqzzsj+=work['带权周转时间']print('周转时间:'+str(zzsj*1.0/len(resultlist)))print('带权周转时间:'+str(dqzzsj*1.0/len(resultlist)))print('')shunxu(fcfs(list1),'先来先服务算法') shunxu(sjf(list2),'短作业优先算法') shunxu(hrrn(list3),'响应比高者优先算法')。
操作系统实验报告+进程调度+作业调度等
操作系统实验报告+进程调度+作业调度等操作系统实验报告1、进程调度2、作业调度3、主存空间的分配与回收4、文件系统学生学院______计算机学院______ 专业班级____网络工程(3)班_____ 学号______3107007062_____ 学生姓名________张菲_______ 指导教师_______胡欣如 _______xx 年 12 月 20 日班_____ 姓名张菲协作者无教师评定_________________ 实验题目进程调度一、实验目的用高级语言编写和调试一个进程调度程序，以加深对进程的概念及进程调度算法的理解。
二、实验内容和要求编写并调试一个模拟的进程调度程序，采用“简单时间片轮转法”调度算法对五个进程进行调度。
每个进程有一个进程控制块（ PCB）表示。
进程控制块可以包含如下信息：进程名、到达时间、需要运行时间、已运行时间、进程状态等等。
进程的到达时间及需要的运行时间可以事先人为地指定（也可以由随机数产生）。
进程的到达时间为进程输入的时间。
进程的运行时间以时间片为单位进行计算。
每个进程的状态可以是就绪 W （Wait）、运行R（Run）两种状态之一。
就绪进程获得 CPU后都只能运行一个时间片。
用运行时间加1来表示。
如果运行一个时间片后，进程的已占用 CPU时间已达到所需要的运行时间，则撤消该进程，如果运行一个时间片后进程的已占用CPU 时间还未达所需要的运行时间，也就是进程还需要继续运行，此时应分配时间片给就绪队列中排在该进程之后的进程，并将它插入就绪队列队尾。
每进行一次调度程序都打印一次运行进程、就绪队列、以及各个进程的 PCB，以便进行检查。
重复以上过程，直到所要进程都完成为止。
三、实验主要仪器设备和材料硬件环境：IBM-PC或兼容机软件环境：C语言编程环境四、实验原理及设计1、进程调度算法：采用多级反馈队列调度算法。
其基本思想是：当一个新进程进入内在后，首先将它放入第一个队列的末尾，按FCFS 原则排队等待高度。
操作系统实验报告作业调度
操作系统实验报告作业调度作业调度是操作系统中的一个重要组成部分，用于管理和分配计算机系统中的作业，确保系统可靠高效地运行。
作业调度算法的选择直接影响到系统的性能和资源利用率。
本实验通过对不同作业调度算法的理论分析和实际测试，探究它们的特点和优劣，最终找到适合特定场景的作业调度算法。
以下是本次实验的详细报告。
一、实验目的1.理解作业调度算法的原理和功能；2.掌握常用的作业调度算法；3.分析和比较不同作业调度算法的优缺点。
二、实验内容1. FIFO（First In First Out）作业调度算法；2. SJF（Shortest Job First）作业调度算法；3. RR（Round Robin）作业调度算法；4. HRN（Highest Response Ratio Next）作业调度算法。
三、实验过程1.FIFO作业调度算法FIFO算法是最简单的作业调度算法，按照作业提交的先后顺序进行调度。
首先将所有作业按照到达时间排序，然后按照顺序依次执行作业。
2.SJF作业调度算法SJF算法是根据作业的执行时间进行排序，优先执行执行时间最短的作业。
通过比较作业的执行时间，选择最短的作业进行执行。
3.RR作业调度算法RR算法是采用时间片轮转的方式进行调度。
每个作业分配一个时间片，当时间片用完后，将该作业移到队列的末尾继续执行。
时间片的长度可以根据需要进行调整。
4.HRN作业调度算法HRN算法是根据作业的响应比来确定调度顺序。
响应比由作业的等待时间和作业执行时间的比值来计算，响应比越大，优先级越高。
选择响应比最高的作业进行执行。
四、实验结果分析在本实验中，我们通过实际测试不同作业调度算法的性能来进行评估。
测试使用了一组模拟作业集，包括不同的作业执行时间和到达时间。
通过对比不同算法的实际表现1.FIFO算法的优点是简单易实现，但缺点是无法考虑作业的执行时间，因此可能导致平均等待时间较长。
2.SJF算法的优点是能够有效地减少平均等待时间，但缺点是对于长作业可能导致短作业长时间等待。
操作系统实验报告作业调度
操作系统实验报告：作业调度1. 引言作业调度是操作系统中的一个重要概念，它涉及到如何合理地安排计算机系统中的作业执行顺序，以最大程度地提高系统的效率和性能。
本文将介绍作业调度的基本概念和主要算法，以及在实验中的应用。
2. 作业调度的概念作业调度是指根据一定的策略和算法，按照一定的顺序从作业队列中选取作业，将其分配给可用资源来执行的过程。
作业调度的目标是实现公平、高效的任务分配，以提高系统的整体性能。
3. 作业调度算法3.1 先来先服务（FCFS）先来先服务是最简单的作业调度算法，即按照作业提交的顺序来执行。
当一份作业到达系统后，它将被放入作业队列的末尾。
一旦当前执行的作业完成，系统将选择队列中的下一个作业来执行。
3.2 短作业优先（SJF）短作业优先算法是根据作业的执行时间来进行调度，执行时间越短的作业优先级越高。
当一个作业进入系统时，系统会检查队列中的所有作业，并选择执行时间最短的作业来执行。
3.3 优先级调度优先级调度算法是根据作业的优先级来进行调度，优先级越高的作业优先级越高。
每个作业都会被分配一个优先级值，系统会按照优先级从高到低的顺序来执行作业。
3.4 时间片轮转调度时间片轮转调度算法将作业分为多个时间片，每个时间片的执行时间相等。
当一个作业进入系统时，系统会分配给它一个时间片，如果在时间片内作业没有完成，则将其放回队列的末尾，并执行下一个作业。
4. 实验中的应用在操作系统实验中，作业调度是一个重要的实验内容。
通过实验，我们可以深入了解不同调度算法的特点和适用场景。
实验中，我们可以使用模拟器来模拟作业调度的过程。
我们可以创建一个作业队列，然后使用不同的调度算法来执行这些作业，并记录它们的执行时间和系统的吞吐量。
通过实验，我们可以比较不同算法在不同场景下的表现，选择最适合当前系统的作业调度算法。
5. 结论作业调度是一个重要的操作系统概念，它决定了系统的性能和效率。
在本文中，我们介绍了作业调度的基本概念和常用算法，并讨论了在实验中的应用。
作业调度实验报告
作业调度实验报告1. 实验目的通过本次实验，使学生了解作业调度算法的基本原理和实现方法，掌握作业调度的实际应用，提高计算机系统的作业吞吐量和系统效率。
2. 实验环境•操作系统：Linux•编程语言：Python•实验工具：CPU模拟器3. 实验原理作业调度是操作系统中的一个重要环节，主要负责将用户提交的作业按照一定的策略分配到CPU上执行。
作业调度的主要目标是提高CPU的利用率，缩短作业的平均等待时间，提高系统的吞吐量。
常用的作业调度算法有先来先服务（FCFS）、短作业优先（SJF）、最短剩余时间优先（SRT）等。
4. 实验内容本次实验主要分为两个部分：一是实现作业调度算法，二是对不同算法进行性能分析。
4.1 作业调度算法实现以先来先服务（FCFS）算法为例，实现作业调度如下：```pythonclass Job:def __init__(self, job_id, arrival_time, execute_time):self.job_id = job_idself.arrival_time = arrival_timeself.execute_time = execute_timeclass JobScheduler:def __init__(self):self.jobs = []def add_job(self, job):self.jobs.append(job)def schedule(self):start_time = 0finish_time = 0for job in self.jobs:if job.arrival_time >= start_time:start_time = job.arrival_timefinish_time = start_time + job.execute_timeprint(f"Job {job.job_id} arrives at {start_time} and finishes a t {finish_time}")start_time = finish_timeif name== “main”:scheduler = JobScheduler()scheduler.add_job(Job(1, 0, 5))scheduler.add_job(Job(2, 1, 3))scheduler.add_job(Job(3, 3, 8))scheduler.schedule()4.2 性能分析通过对不同作业调度算法的模拟运行，分析其性能指标，如平均等待时间、平均响应时间、吞吐量等。
操作系统实习报告
操作系统实习报告在大学的学习生涯中，操作系统作为计算机科学的核心课程，为我们揭示了计算机系统运行的神秘面纱。
为了更深入地理解操作系统的原理和机制，我参加了一次操作系统的实习。
这次实习不仅让我将理论知识应用到实际中，更让我对计算机系统的运行有了全新的认识。
实习的开始，我们首先对操作系统的基本概念进行了回顾。
操作系统是管理计算机硬件与软件资源的程序，同时也是计算机系统的内核与基石。
它负责诸如进程管理、内存管理、文件系统管理、设备管理等重要任务。
这些概念在课堂上虽然已经学习过，但在实际操作中，才真正感受到它们的重要性和复杂性。
在进程管理方面，我们通过编程实现了进程的创建、调度和终止。
进程是操作系统中最基本的执行单元，理解其工作原理对于优化系统性能至关重要。
通过实际编写代码，我学会了如何使用系统调用创建新的进程，以及如何设置进程的优先级和调度策略。
例如，在多任务环境中，合理地分配 CPU 时间片可以确保各个进程都能得到及时的处理，从而提高系统的整体响应速度。
内存管理是操作系统的另一个关键领域。
我们学习了如何实现内存的分配和回收，以及虚拟内存的概念。
在实际编程中，使用动态内存分配函数（如malloc 和free）时，需要特别注意内存泄漏和碎片问题。
虚拟内存技术使得计算机能够运行比物理内存更大的程序，通过将暂时不使用的内存页面交换到磁盘上，有效地扩展了内存空间。
然而，这也带来了页面置换算法的挑战，如何选择最优的页面进行置换，以减少磁盘 I/O 操作，提高系统性能，是一个需要深入思考的问题。
文件系统是操作系统用于组织和管理数据的重要机制。
我们实现了简单的文件创建、读写和删除操作。
了解文件的存储结构、目录的组织方式以及文件权限的设置，对于保证数据的安全性和完整性非常重要。
同时，文件系统的缓存机制和磁盘调度算法也会影响文件操作的性能，需要在设计和实现中进行优化。
设备管理方面，我们学习了如何与外部设备进行通信和控制。
线程调度实习报告
线程调度实习报告姓名李炜学号1100012810日期2014年3月6日目录内容一：总体概述 (3)内容二：任务完成情况 (3)任务完成列表（Y/N） (3)具体Exercise的完成情况 (3)内容三：遇到的困难以及解决方法 (7)内容四：收获及感想 (7)内容五：对课程的意见和建议 (7)内容六：参考文献 (8)内容一：总体概述这次的实习任务主要是通过对Nachos线程的调度机制来加深对线程调度的理解，因为Nachos本身是没有很复杂的调度机制的，所以这次实习中需要首先向Nachos添加带有优先级的线程调度算法，之后添加使用时间片调度，来使得线程的调度相对公平。
内容二：任务完成情况任务完成列表（Y/N）具体Exercise的完成情况第一部分Exercise1首先来看windows的线程调度，windows的调度单位就是线程，它采用的时基于动态优先级的、抢占式调度，结合时间配额调整，总是运行最高优先级线程。
就绪线程会按优先级进入相应队列，系统总是选择优先级最高的就绪线程让其运行，同一优先级的各线程按时间片轮转进行调度，多处理机系统中允许多个线程并行运行。
从这一点来看，有些像多级反馈队列调度的方法。
线程调度的触发事件有四种：一个线程进入就绪状态，如一个刚创建的新线程或一个刚刚结束等待状态的线程一个线程由于时间配额用完、从运行状态转入结束状态或等待状态一个线程由于调用系统服务而改变优先级或被Windows 系统本身改变其优先级一个正在运行的线程改变了它的亲合处理机集合Windows使用32个线程优先级，分成三类，实时优先级，可变优先级，系统线程（IDLE）。
一个线程用完了自己的时间配额时，如果没有其它相同优先级线程，Windows将重新给该线程分配一个新的时间配额，并继续运行。
当线程被抢占时，它被放回相应优先级的就绪队列的队首处于实时优先级的线程在被抢占时，时间配额被重置为一个完整的时间配额处于动态优先级的线程在被抢占时，时间配额不变，重新得到处理机后将运行直到剩余的时间配额用完如果刚用完时间配额的线程优先级降低了，Windows 将寻找一个优先级高于刚用完时间配额线程的新设置值的就绪线程如果刚用完时间配额的线程的优先级没有降低，并且有其他优先级相同的就绪线程，Windows 将选择相同优先级的就绪队列中的下一个线程进入运行状态，刚用完时间配额的线程被排到就绪队列的队尾(即分配一个新的时间配额并把线程状态从运行状态改为就绪状态)配额并继续运行下面来看linux的线程调度策略，linux将进程分为下面两类实时进程对调度延迟的要求最高，要求立即响应并执行调度策略：FIFO、Round Robin普通进程普通进程调度策略使用CFS，CFS是现在被内核采纳的调度器。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
线程调度实习报告目录内容一：总体概述 (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 进程下的，所以它不属于任何用户进程上下文。
调度代码在适当的时机会切换进程上下文, 这里的切换进程上下文是指进程环境的切换, 包括内存中的可执行程序, 提供程序运行的各种资源. 进程拥有虚拟的地址空间, 可执行代码, 数据, 对象句柄集, 环境变量, 基础优先级, 以及最大最小工作集等的切换。