搶占式優先級調度算法是什么意思

系統把處理機分配給優先權最高的進程，使之執行。但在其執行期間，只要又出現了另一個其優先權更高的進程，進程調度程序就立即停止當前進程(原優先權最高的進程)的執行，重新將處理機分配給新到的優先權最高的進程。

 

 本教程操作環境：windows7系統、C++17版本、Dell G3電腦。

搶占式優先權調度算法

在這種方式下，系統把處理機分配給優先權最高的進程，使之執行。但在其執行期間，只要又出現了另一個其優先權更高的進程，進程調度程序就立即停止當前進程(原優先權最高的進程)的執行，重新將處理機分配給新到的優先權最高的進程。因此，在采用這種調度算法時，是每當系統中出現一個新的就緒進程i 時，就將其優先權Pi與正在執行的進程j 的優先權Pj進行比較。如果Pi≤Pj，原進程Pj便繼續執行；但如果是Pi>Pj，則立即停止Pj的執行，做進程切換，使i 進程投入執行。顯然，這種搶占式的優先權調度算法能更好地滿足緊迫作業的要求，故而常用於要求比較嚴格的實時系統中，以及對性能要求較高的批處理和分時系統中。

具體代碼：

#include #include #include using namespace std;using std::cout;struct PCB

{    // 進程名

    string name;    // 到達時間

    int arrivetime;    // 運行時間

    int runtime;               

    // 仍需運行時間

    int resttime;    // 開始時間

    int starttime;    // 完成時間

    int endtime;    // 運行次數

    int runcount;    // 周轉時間

    int zhouzhuangtime;    // 帶權周轉時間（周轉時間/運行時間)

    double weightzhouzhuangtime;    // 優先級（靜態）

    int priority;

 

    PCB *next;

};// 進程數int num_process;// 記錄所有進程的總時間int totaltime;// 記錄所有進程的總帶權周轉時間double weighttotaltime;

 

PCB *createPCB()

{    int i;    // 定義隊首、隊尾

    PCB *head, *rear;    // 初始化

    head = rear = NULL;    // 臨時指針變量

    PCB *p;    cout<<"請輸入進程數量：";    cin>>num_process;    for(i = 0; i < num_process; i++)

    {        // 初始化一個空間給進程

        p = new PCB;        cout<<"請依次輸入第"<>p->name>>p->priority>>p->arrivetime>>p->runtime;

        p->resttime = p->runtime;

        p->runcount = 1;

        totaltime += p->runtime;

        p->starttime = 0;

        p->endtime = 0;

        p->zhouzhuangtime = 0;

        p->weightzhouzhuangtime = 0;

        p->next = NULL;        // 存入鏈表中

        if(rear == NULL)

        {

            head = p;

            rear = p;

        }        else

        {

            rear->next = p;

            rear = p;

        }

 

    }    return head;

}// 鏈表插入排序PCB *insertSort(PCB *head)

{    /*

        1、先在原鏈表中以第一個節點為一個有序鏈表，其余節點為待定節點；

        2、從待定節點中取節點，插入到有序鏈表中相應位置；

        3、實際上只有一條鏈表，在排序中，實際只增加了一個用於指向剩下需要排序節點的頭指針。

    */

    PCB *first;// 為原鏈表剩下用於直接插入排序的節點頭指針

    PCB *t; // 臨時指針變量：要插入的節點

    PCB *p; // 臨時指針變量：要插入的位置

    PCB *q; // 臨時指針變量：指向原鏈表

 

    first = head->next;

    head->next = NULL; // 只含有一個節點的鏈表的有序鏈表

 

    while(first != NULL) // 遍歷剩下的無序鏈表

    {        // 無序節點在有序鏈表中找插入位置p

        for(t = first, q = head; (q != NULL) && (q->arrivetime < t->arrivetime); p = q, q = q->next);        // 無序鏈表中的節點離開，以便插入到有序鏈表中

        first = first->next;        if(q == head)// 插入在第一個節點之前

        {

            head = t;

        }        else// p是q的前驅

        {

            p->next = t;

        }

        t->next = q;// 完成插入動作

    }    return head;

}// 獲取當前時間段內的進程數量int getCurrentNumOfProcess(PCB *head, int time)

{    int count = 0;

    PCB *t;// 臨時指針變量，指向鏈表

    t = head;    while(t != NULL && t->arrivetime <= time)

    {

        count++;

        t = t->next;

    }    return count;

}// 刪除當前節點PCB* deletePCB(PCB *head, PCB *t)

{

    PCB *p, *q;

    p = head;

    q = p->next;    // 刪除節點是頭節點

    if(t == head)

    {

        head = head->next;

    }    else

    {        while(q != t)// 跳出循環之后q為該節點，p為前一節點

        {

            p = p->next;

            q = p->next;

        }        if(t->next == NULL)// 刪除節點是尾節點

            p->next = NULL;        else

            p->next = q->next;

    }    // 刪除

    free(t);    return head;

}// 在頭節點后的count個節點中選擇優先數最大的返回PCB *findMaxPriority(PCB *head, int count)

{    int max;

    PCB *p, *q, *f;

    q = head;

    max = q->priority;

    f = q;    while(count > 0)

    {        if(q->priority > max)

        {

            max = q->priority;

            f = q;

        }

        count--;

        q =q->next;

    }    return f;

 

}/*

    輸出a時間內的特定輸出格式,當某一時間段內沒有進程工作時，進程名稱為0

    進程名稱.進程工作時間，進程與進程間以|分隔

    輸入：1 3 2 8

          2 2 1 7

          3 6 3 12

    輸出：[0.1|2.1|1.1|3.12|1.7|2.6|0.172]

*/void print(vector vec_output, int a)

{    for(int i = 0; i < vec_output.size(); i++)

    {        cout<<"******************************************"<
    }    // 輸出周轉時間信息,只有進程結束了才輸出

    int i;    for(i = 0; i < vec_output.size()-1; i++)

    {        bool flag = true;        for(int j = i+1; j < vec_output.size(); j++)

        {            if(vec_output[j].name == vec_output[i].name)

            {

                flag = false;                break;

            }

        }        if(flag)

        {            cout<<"進程"<
        }

    }    cout<<"進程"<
    cout<<"平均周轉時間："< 0)

    {        cout<<"0."<
    }    if(vec_output[vec_output.size() - 1].endtime < a)

    {        for(int i = 0; i < vec_output.size(); i++)

        {            cout<
            if(i+1 < vec_output.size() && vec_output[i].endtime != vec_output[i+1].starttime)

            {                cout<<"0."<
            }

        }        cout<<"0."<
    }    else if(vec_output[vec_output.size() - 1].endtime == a)

    {        for(int i = 0; i < vec_output.size()-1; i++)

        {            cout<
            if(i+1 < vec_output.size() && vec_output[i].endtime != vec_output[i+1].starttime)

            {                cout<<"0."<
            }

        }        cout<
    }    else

    {        for(int i = 0; i < vec_output.size(); i++)

        {            if(vec_output[i].endtime <= a)

            {                cout<
                if(i+1 < vec_output.size() && vec_output[i].endtime != vec_output[i+1].starttime)

                {                    cout<<"0."<
                }

            }            else

            {                cout<
            }

        }

    }

}void PCB_MAIN(PCB *head)

{

    head = insertSort(head);    int time = 0;// 模擬時間變量

    int count;// 當前時間內運行的進程數量

    PCB *q;    vector vec_out;//輸出

    PCB temp;    while(head != NULL)

    {

        count = getCurrentNumOfProcess(head, time);        if(count == 0)

            time++;        else

        {            /************************************************************************/

            /* 搶占式                                                               */

            /************************************************************************/

            // 找出優先數最大的線程

            q = findMaxPriority(head, count);            if(q->runcount == 1)// 該進程第一次運行

            {

                q->starttime = time;                // 輸出信息

                temp = *q;

                temp.endtime = 0;

                temp.next = NULL;                if(vec_out.size() != 0 && vec_out[vec_out.size()-1].endtime == 0)

                {

                    vec_out[vec_out.size()-1].endtime = temp.starttime;

                }

                vec_out.push_back(temp);

            }

            ++time;

            ++q->runcount;

            --q->resttime;            if(q->resttime == 0)// 該進程運行結束

            {                // 記錄結束時間

                q->endtime = time;                // 計算周轉時間

                q->zhouzhuangtime = time - q->arrivetime;                // 計算帶權周轉時間

                q->weightzhouzhuangtime = q->zhouzhuangtime/(double)q->runtime;

                weighttotaltime += q->weightzhouzhuangtime;                // 輸出信息

                temp = *q;

                temp.starttime = 0;

                temp.next = NULL;                if(vec_out[vec_out.size()-1].name == temp.name)

                {

                    vec_out[vec_out.size()-1].endtime = temp.endtime;

                    vec_out[vec_out.size()-1].zhouzhuangtime = temp.zhouzhuangtime;

                    vec_out[vec_out.size()-1].weightzhouzhuangtime = temp.weightzhouzhuangtime;

                }                else

                {

                    temp.starttime = vec_out[vec_out.size()-1].endtime;

                    vec_out.push_back(temp);

                }                // 刪除該進程

                //deletePCB(q);

                head = deletePCB(head, q);

            }

        }

    }    // 輸出200時間單位內的執行順序

    print(vec_out, 200);

}int main()

{

    PCB *head = NULL;

    head = createPCB();

    PCB_MAIN(head);    return 0;

}

輸出實例

輸入：

 

 輸出：

 

 

 

 

 

 以上就是搶占式優先級調度算法是什么意思的詳細內容。（拼多多培訓）