单处理器环境不需要自旋锁，调用了自旋锁的函数，里面也不是自旋锁的实现，只不过是用了层壳而已
原因是：
如果是非抢占的系统：（高优先级的进程不能中止正在内核中运行的低优先级的进程而抢占CPU运行。进程一旦处于核心态(例如用户进程执行系统调用)，则除非进程自愿放弃CPU，否则该进程将一直运行下去，直至完成或退出内核。）
一个进程（进入到了内核态），或者线程用了自旋锁，没有执行完毕之前，没有别的进程或者内核线程跟他抢，即使是时间片到了之 后，接着还是分给本进程或者线程。
如果是软中断或者是中断打断了怎么办？ 没关系，关中断即可。也就是说，这时自旋锁退化成关开中断


如果是抢占的系统：（即当进程位于内核空间时，有一个更高优先级的任务出现时，如果当前内核允许抢占，则可以将当前任务挂起，执行优先级更高的进程。）
自旋锁的定义变成非抢占即可，这时高优先级进程就没法跟他抢了。中断是一样的处理。


总之，单处理器来说，非抢占的话，自旋锁退化为 关开中断；
对于抢占来说，自旋锁变成  禁止/打开抢占+关开中断

处理器调度类型





调度算法
· 选择调度策略
决策模式：非抢占：在这种情况下，一旦进程处于运行状态吗，它就不断执行直到终止。
   抢占：当前正在运行的进程可能被操作系统终端，并转移到就绪状态。


先来先服务（FCFS）：当每个进程就绪后，它就加入就绪队列。当前正在运行的进程停止执行时，选择在就绪队列中存在时间最长的进程运行。
时间片轮转：以一个周期性间隔产生时间中断，当中断发生时，当前正在运行的进程被置于就绪队列中，然后基于FCFS策略选择下一个就绪作业运行。
最短进程优先（SPN）：下一次选择预计处理时间最短的进程，并且不抢占进程。
最短剩余时间优先（SRT）：针对SPN增加了抢占机制的版本，调度程序总是选择与其剩余时间最短的进程。当另一个进程就绪时，这个进程可能会被抢占。
反馈：建立一组调度队列，基于每个进程的执行历史和其他一些准则，把它们分配到各个队列中。

本次实现的是模拟在单处理器情况下的处理器调度，目的是设计一个按优先数调度算法实现处理器调度的程序。

每一个进程用一个进程控制块PCB来代表，进程控制块的格式为：

进程名——作为进程的标识，假设五个进程的进程名分别为P1，P2，P3，P4，P5。

指针——按优先数的大小把五个进程连成队列，用指针指出下一个进程的进程控制块的首地址，最后一个进程中的指针为“0”。

要求运行时间——假设进程需要运行的单位时间数。

优先数——赋予进程的优先数，调度时总是选取优先数大的进程先执行。

状态——可假设有两种状态，“就绪”状态和“结束”状态。五个进程的初始状态都为“就绪”，用“R”表示，当一个进程运行结束后，它的状态为“结束”，用“E”表示。

 

#include <stdio.h>                                                                                                     
#include <malloc.h>
#include <assert.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <string.h>
#define NAMEMAX 64
#define PROCMAX 64
typedef enum Status{
    R,                 //就绪
    E                  //结束
}Status;
typedef struct Proc{
    char name[NAMEMAX];//进程名
    char next[NAMEMAX];//下一个需要调度的进程的名字
    size_t run_time;   //要求运行时间
    int prio_num;      //优先数
    Status status;     //状态
}Proc;

typedef struct ProcQueue{//进程队列结构体
    Proc* data;          //指向在堆上动态开辟的内存空间,用来存放进程控制块
    size_t size;         //队列中有效进程的个数
    size_t capatity;     //队列的最大容量,如果数据达到最大容量，就要重新开辟一块更大的内存
}ProcQueue;
//进程队列初始化
void ProcQueueInit(ProcQueue* queue)
{
    if(queue == NULL)
    {
        return;
    }
    queue->size = 0;
    queue->capatity = 100;
    queue->data = (Proc*)malloc(sizeof(Proc)*queue->capatity);
    assert(queue->data != NULL);
}            
//销毁进程队列
void DestroyProcQueue(ProcQueue* queue)
{
    if(queue == NULL)
    {
        return;
    }                                                                                                                                   
    free(queue->data);
    queue->size = 0;
    queue->capatity = 0;
}
void ProcQueuePush(ProcQueue* queue,Proc pro);
//创建进程对象
void CreateProc(ProcQueue* queue, Proc* pro,size_t n)
{
    if(pro == NULL)
    {
        return;
    }
    strcpy(pro->next,pro->name); 
    size_t i = 0;
    printf("请输入进程编号(如P1,P2,P3)...\n");
    for(; i < n; ++i)
    {
        scanf("%s",pro->name);
        pro->status = R;
        srand((unsigned)time(NULL));//采用随机数法为每个进程输入对应数据
        pro->prio_num = rand()%6+1;
        pro->run_time = rand()%6+1;
        ProcQueuePush(queue,*pro);
    }
}
//如果当前进程队列满了，就要动态扩容
Proc* ProcQueueExpand(ProcQueue* queue)
{
    if(queue == NULL)
    {
        return NULL;
    }
    Proc* new_proc = (Proc*)malloc(sizeof(Proc)*2*queue->capatity+1);
    queue->capatity = 2*queue->capatity + 1;
    size_t i = 0;
    for(; i < queue->size ; i++)
    {
        new_proc[i] = queue->data[i];
    }
    free(queue->data);
    return new_proc;
}
//对进程队列进行冒泡排序
void ProcQueueBubble(ProcQueue* queue)
{
    if(queue == NULL)
    {
        return;
    }
    size_t i = 0;
    Proc tmp;
    for(;i < queue->size;i++)
    {
        size_t j = 0;
        for(; j < queue->size-i-1;j++)
        {
            if(queue->data[j].prio_num < queue->data[j+1].prio_num)                                                                     
            {
                tmp = queue->data[j];
                queue->data[j] = queue->data[j+1];
                queue->data[j+1] = tmp;
            }
        }
    }
}
//插入进程
void ProcQueuePush(ProcQueue* queue, Proc pro)
{
    if(queue == NULL)
    {
        return;
    }
    if(queue->size == queue->capatity)
    {
        //进程队列满了，进行动态扩容
        queue->data = ProcQueueExpand(queue);
    }
    //先插入到队列尾部，然后进行排序
    //每次的进程队列都是排好序的
    //如果新插入的进程状态为结束，就不进行排序
    if(pro.status != E)
    {
        queue->data[queue->size++] = pro;
        ProcQueueBubble(queue);
        size_t i = 0;
        for(; i < queue->size;i++)
        {
            if(i+1 == queue->size && queue->data[i+1].status != E)
            {
                strcpy(queue->data[i].next,queue->data[0].name);
            }
            else                                                                                                                        
            {
            strcpy(queue->data[i].next,queue->data[i+1].name);
            }
        }
    }
    else
    {
        strcpy(pro.next,"  ");
        queue->data[queue->size] = pro;
    }
}
//进程调度
void ProcQueueRun(ProcQueue* queue)
{
    if(queue == NULL )
    {
        return;
    }
    if(queue->size != 0)
    {
        if(queue->data[0].run_time > 0)//进程运行时间大于0才能进行调度
        {
            queue->data[0].run_time--;//运行时间减一
            queue->data[0].prio_num--;//优先级数减一
        }
        else
        {
            queue->data[0].status = E;//否则进程状态设置为E
        }
        Proc run_proc = queue->data[0];
        size_t i = 0;
        for(;i < queue->size-1;i++)
        {
            queue->data[i] = queue->data[i+1];
        }                                                                                                                               
        queue->size--;                //进程调度时相当于出队列，所以要从队列中删除
       ProcQueuePush(queue,run_proc); //调度完再入队列
    }
}
//打印进程队列信息
void ProcQueuePrint(ProcQueue* queue,size_t n)
{
    if(queue == NULL)
    {
        return;
    }
    printf("=============================\n");
    printf("NAME STATUS RUNTIME NICE NEXT\n");
    printf("=============================\n");
    size_t i = 0;
    for(; i < n ; i++)
    {
        printf(" %s  ",queue->data[i].name);
        if(queue->data[i].status == R)
        {
            printf("   R   ");
        }else
        {
            printf("   E   ");
        }
        printf("   %lu    ",queue->data[i].run_time);
        printf("  %d  ",queue->data[i].prio_num);
        printf("  %s",queue->data[i].next);
        printf("\n");
    }
}
int main()
{
    ProcQueue queue;
    Proc pro;                                                                                                                           
    size_t n = 0;
    ProcQueueInit(&queue);
    printf("请输入您想拥有的进程数: \n");
    scanf("%lu",&n);
    CreateProc(&queue,&pro,n);
    while(1)
    {
        if(queue.size == 0)
        {
            break;
        }
        printf("\n");
        ProcQueuePrint(&queue,n);
        getchar();
        ProcQueueRun(&queue);
    }
    ProcQueuePrint(&queue,n);
    return 0;
}   


 

在多道程序设计系统中，内存中有多个进程。每个进程或者正在处理器上运行，或者正在等待某些事件的发生，比如IO完成。处理器通过执行某个进程而保持忙状态，而此时其他进程处于等待状态。



一、处理器调度的类型

处理器调度的目标是以满足系统目标（如响应时间、吞吐率、处理器小雷）的方式，把进程分配到一个或多个处理器中执行。

在许多系统中，这个调度活动分成三个独立功能：长程、中程和短程调度。他们的名字表明在执行这些功能时的相对时间比例。

创建新进程时，执行长程调度，它决定是否把进程添加到当前活跃的进程集合中。

中程调度是交换功能的一部分，它决定是否把进程加到那些至少部分在内存中并且可以被执行的进程集合中。

短程调度真正决定下一次执行哪一个就绪进程。

从根本上说，调度属于队列管理方面的问题，用来在排队环境中减少延迟和优化性能。

1 长程调度

长程调度决定哪一个程序可以进入系统中处理，因此，它控制着系统的并发度。一旦允许进入，一个作业或用户程序就成为一个进程，并被添加到供短程调度程序使用的队列中等待调度。在某些系统中，一个新创建的进程开始处于被换出状态，在这种情况下，它被添加到供中程调度程序使用的队列中等待调度。

在批处理系统或者操作系统的批处理部分中，新提交的作业被发送到磁盘，并保存在一个批处理队列中。在长程调度程序运行的时候，从队列中创建相应的进程。这里涉及两个决策：调度程序必须决定什么时候操作系统能够接纳一个进程或者多个进程；同时，调度程序必须决定接受哪个作业或哪些作业，并将其转变成进程。

2 中程调度

中程调度时交换功能的一部分。在典型情况下，换入决定取决于管理系统并发度的需求。

3 短程调度

考虑执行的频繁程度，长程调度程序执行的频率相对较低，并且仅仅是粗略地决定是否接受新进程及接受哪一个。为进行交换决定，中程调度程序执行得略微频繁一些。

短程调度程序，也称为分派（dispatcher）程序，执行的最频繁，并且精确地决定下一次执行哪一个进程。

二、调度算法

1 短程调度准则

短程调度的主要目标是按照优化系统一个或多个方面行为的方式来分配处理器时间。通常使用的准则可以按两个维度来分类：面向用户的准则与单个用户或进程感知到的系统行为相关；面向系统的准则的重点是处理器使用效果和效率（比如吞吐量，也就是进程的完成的速度）。

面向用户的准则：响应时间、周转时间（周转时间 = 完成时间 - 到达时间） 
面向系统的准则：吞吐量、处理器利用率

设计一个调度策略涉及在互相竞争的各种要求之间进行折中，根据系统的本质和使用情况，给各种要求设定相应的权值。

2 优先级的使用

在许多系统中，每个进程都被指定一个优先级，调度程序总是有些选择具有较高优先级的进程。

3 选择调度策略

选择函数确定在就绪进程中选择哪一个进程在下一次执行。

决策模式说明选择函数在被执行的瞬间的处理方式，通常可分为以下两类：

非抢占。在这种情况下，一旦进程出于运行状态，它就不断执行直到终止，或者因为等待IO，或者因为请求某些操作系统服务，而阻塞自己。
抢占。当前正中运行的进程可能被操作系统中断，并转移到就绪态。关于抢占的决策可能是在一个新进程到达时，或者在一个中断发生后，把一个被阻塞的进程职位就绪态时，或者出现基于周期性的时间中断时。
与非抢占策略相比，抢占策略可能会导致较大的开销，但是可能会对所有进程提供较好的服务，因为它们避免了任何一个进程独占处理器太长时间。此外，通过使用有效的进程切换机制，以及提供较大的内存，使得大部分程序都在内存中，可使抢占的代价相对比较低。

周转时间：就是驻留时间，或者这一项在系统中花费的总时间。
归一化周转时间：周转时间与服务时间的比率，该值表示一个进程的相对延迟。
1）先来先服务（FCFS）：当美国进程就绪后，它就入就绪队列。当前正在运行的进程停止执行时，选择在就绪队列中存在时间最长的进程运行。

2）轮转：一种简单的方法是采用使用基于时钟的抢占策略，在这类方法中，最简单的是轮转算法。以一个周期性间隔产生时钟中断，当中断发送时，当前正在运行的进程被置于就绪队列中，然后基于FCFS策略选择下一个就绪作业运行。这种技术也称为时间片，因为每个进程在被抢占前都给定一片时间。

3）最短进程优先：这是一个非抢占的策略，其原则是下一次选择预计处理时间最短的进程。因此，短进程将会越过长进程，跳到队列头。

4）最短剩余时间：调度程序总是选择预期剩余时间最短的进程。当一个新进程加入就绪队列时，它可能比当前运行的进程具有更短的剩余时间，因此，只要新进程就绪，调度程序就可能抢占当前正在运行的进程。

5）最高响应比优先：响应比=（等待处理器的时间+预计的服务时间）/预计的服务时间

6）反馈法：建立一组调度队列，基于每个进程的执行历史和其他一些准则，把他们分配到各个队列中。

4 公平共享调度

如果当用户的应用程序或作业可以组成多个进程（或线程），就会出现传统的调度程序不认识的进程集合结构。从用户的角度看，他所关心的不是某个特定的进程如何执行，而是构成应用程序的一组进程如何执行。因此，基于进程组的调度策略是非常具有吸引力的，该方法通常称为公平共享调度。

术语“公平共享”表明了这类调度程序的基本原则。每个用户被指定了某种类型的权值，该权值定义了该用户对系统资源的共享，而且是作为在所有使用的资源中所占的比例来体现的。

5.进程调度算法的实例



进程调度方式有两种：

非抢占方式 

分配 CPU 后，进程一直运行到完成或异常终止 
简单、系统开销小 
批处理系统
抢占方式 

系统根据某种策略（抢占原则）收回正在运行进程的 CPU ，调度其它就绪进程运行 
及时响应各进程的需求
分时/实时系统
抢占原则：

时间片原则（时间片用完）
优先级原则（更高优先级进程就绪）
短进程优先原则（更短进程就绪）
（1）先来先服务FCFS

FCFS 算法总是把处理机分配给最先进入就绪队列的进程，一个进程一旦分得处理机，便执行下去，直到该进程完成或阻塞时，才释放处理机。（非抢占调度） 



FCFS 的优点：实现简单。  

FCFS 的缺点：没有考虑进程的优先级，平均等待时间波动较大，短进程可能排在长进程后面，I/O 资源和 CPU 资源利用率低。  

FCFS 有利于长作业（进程）

（2）时间片轮转RR

RR 用于分时系统进程调度，其步骤如下：

1.就绪进程按照 FCFS 原则排成一个就绪队列 

2.调度队首进程，执行一个时间片 

3.在一个时间片结束时，发生时钟中断 

4.调度程序暂停当前进程的执行，并送就绪队列尾 

5.通过 CPU 现场切换执行当前的队首进程

这里的时间片 q = 1



RR 的优点：就绪队列中的所有进程都会有机会获得处理器运行；可提高进程并发性和资源利用率；缩短响应时间。

RR 的缺点：时间片的长度影响系统开销和响应时间。

时间片过短，则调度程序剥夺处理机的次数增多，增加进程上下文交换次数，加重了系统开销（时间片短，有利于短作业，不利于长作业）；  

时间片过长，大到进程能完成全部运行作业所需的时间，那么时间片轮转法就退化为 FCFS （长时间片，无法满足交互式用户需求）。  

最佳时间片，长度略大于一次典型交互所需的时间（响应时间= 进程数目 × 时间片大小）

（3）最短进程优先SPN

SPN 算法从就绪队列中选出估计运行时间最短的进程，为之分配处理机，如果运行时间相同，按 FCFS 调度。

SPN 算法有抢占方式和非抢占方式两种：

最短进程优先SPN（非抢占） 

最短剩余时间优先SRT（抢占）



SPN 的优点：能有效地降低平均等待时间，提高系统的吞吐量（平均周转时间最短），有利于短作业。  

SPN 的缺点：不利于长作业当短作业持续不断到达时，长作业可能被饿死。无法准确估计作业的的确切执行时间，不一定能真正做到短作业（进程）优先调度。

（4）最短剩余时间优先SRT

SRT 是对 SPN 的改进，采用了抢占机制，根据就绪队列里进程剩余需要服务的时间来排队。剩余时间越短的排在最前面。因为需要去记录进程的剩余服务时间，所以增加了系统的开销。



SRT 的优点：比 SPN 的性能更好，短作业只要就绪就可以抢占正在执行长进程的 CPU。  

SRT 的缺点：增加了额外开销，长作业（进程）可能会被饿死。

（5）最高相应比优先HRRN

为了防止长作业（进程）被饿死，选择最高相应比优先算法。  
响应比 = 周转时间 / 运行时间 = （运行时间 + 等待时间 ）/ 运行时间 = 1 + 等待时间 / 运行时间



HRRN 的优点：对短作业有利（运行时间越短优先级越高），长作业不会被饿死（运行时间相同时，等待时间越长优先级越高）  

HRRN 的缺点：增加了系统的开销（每次重新调度需要估计运行时间，并计算响应比）

（6）反馈法

多级队列调度：

根据进程属性设置多个就绪队列，每个就绪队列有各自的调度算法、优先级或时间片长度  

前台（或交互式）RR  

后台（或批处理）FCFS

队列之间必须有调度  

通常采用固定优先级可抢占调度  

另一种可能是在队列之间划分时间片。每个队列都有一定的 CPU 时间

多级反馈队列： 

基于多级队列调度（多个队列，不同优先级，不同时间片长度，不同调度算法） 

进程可以在不同队列间移动 

可抢占调度 

最通用和最复杂的 CPU 调度算法

多级反馈队列调度的优点：

a.短进程出现在优先级高的队列中，可提高系统吞吐量、缩短平均周转时间 

b.I/O 密集型进程放在最高优先级队列，保证及时 I/O 交互，提高 I/O 设备利用率、缩短响应时间 

c.不必事先估计进程执行时间，可以在进程中动态调节

6.多种调度算法的比较



三、传统的UNIX调度

传统的UNIX调度程序采用了多级反馈，而在每个优先级队列中采用了轮转的方法。该系统使用1秒抢占方式，也就是说，如果一个正在运行的进程在1秒内未被阻塞或者完成，它将被抢占。优先级基于进程类型和执行历史。

四 、小结

操作系统根据进程的执行对三种类型的调度方案作出选择。长程调度决定何时允许一个新进程进入系统。中程调度是交换功能的一部分，它决定何时把一个程序的部分或全部取进内存，使得该程序能够被执行。短程调度决定哪一个就绪进程下一次被处理器执行。本章集中讨论与短程调度相关的问题。

在设计短程调度程序时使用了各种各样的准则。一些准则与单个用户察觉到的系统行为有关（面向用户），而其他准则查看系统在满足所有用户的需求时的总效率（面向系统）。一些准则与性能的定量度量有关，另一些在本质上是定性的。从用户角度看，相应时间通常是系统最重要的一个特性；从系统的角度看，吞吐量或处理器利用率是最重要的。