對優先順序進行調整的演算法是

1. 誰知道「優先調度演算法」

應該是：優先順序調度演算法吧
給每個任務定一個優先順序，優先順序高的可以先進行處理，
優先順序低的只能等待，
如果優先順序一樣，可以採用先來先服務進行處理。

2. css優先順序計算規則

梳理這部分是因為在使用組件模式開發h5應用會出現組件樣式修改未生效的問題，在解決樣式修改的問題前，需要理清楚CSS樣式生效的優先順序。樣式根據引入和聲明需要分開介紹，分為 引入樣式優先順序 和 聲明樣式優先順序 。

引入樣式優先順序

引入樣式優先順序一般是在外部樣式、內部樣式、內聯樣式之間應用同一個樣式的情況是使用， 優先順序如下：

外部樣式 | 內部樣式 < 內聯樣式

外部樣式 和 內部樣式 ，最後出現的優先順序最高，例如：

<!-- 內聯樣式 --><spanstyle="color:red;">Hello</span><styletype="text/css">/* 內部樣式 */h3{color:green;}</style><!-- 外部樣式 style.css --><linkrel="stylesheet"type="text/css"href="style.css"/>

因此，對於一些重置的樣式集，比如 normalize.css/reset.css 必須寫在所有樣式的前面。

PS: 沒有外聯樣式， 參考 。

聲明樣式優先順序

1. 大致的優先順序

一般來說滿這個規則：

繼承不如指定

!important > 內聯 > ID > Class|屬性|偽類 > 元素選擇器

:link、:visited、:hover、:active按照LVHA（LoVe HAte）順序定義

上面是優先順序演算法反映出的大致結果，在一般的開發中熟記即可。如果需要進一步研究原理，則了解下優先順序演算法。

2. 優先順序演算法

選擇器的特殊性值分為四個等級，如下：

等級標簽內選擇符ID選擇符Class選擇符/屬性選擇符/偽類選擇符元素選擇符

示例<span style="color:red;">#text{color:red;}.text{color:red;} [type="text"]{color:red}span{color:red;}

標記位x,0,0,00,x,0,00,0,x,00,0,0,x

特點:

每個等級的初始值為0，

每個等級的疊加為選擇器出 現的次數相加

不可進位，比如0,99,99,99

依次表示為：0,0,0,0

每個等級計數之間沒關聯

等級判斷從左向右，如果某一位數值相同，則判斷下一位數值

如果兩個優先順序相同，則最後出現的優先順序高，!important也適用

通配符選擇器的特殊性值為：0,0,0,0

繼承樣式優先順序最低 ，通配符樣式優先順序高於繼承樣式

計算示例：

a{color: yellow;} /*特殊性值：0,0,0,1*/

div a{color: green;} /*特殊性值：0,0,0,2*/

.demo a{color: black;} /*特殊性值：0,0,1,1*/

.demo input[type="text"]{color: blue;} /*特殊性值：0,0,2,1*/

.demo *[type="text"]{color: grey;} /*特殊性值：0,0,2,0*/

#demo a{color: orange;} /*特殊性值：0,1,0,1*/

div#demo a{color: red;} /*特殊性值：0,1,0,2*/

生效示例：

<ahref="">第一條應該是黃色</a><!--適用第1行規則--><divclass="demo"><inputtype="text"value="第二條應該是藍色"/><!--適用第4、5行規則，第4行優先順序高--><ahref="">第三條應該是黑色</a><!--適用第2、3行規則，第3行優先順序高--></div><divid="demo"><ahref="">第四條應該是紅色</a><!--適用第6、7行規則，第7行優先順序高--></div>

關於偽類LVHA的解釋

a標簽有四種狀態：鏈接訪問前、鏈接訪問後、滑鼠滑過、激活，分別對應四種偽類:link、:visited、:hover、:active；

當滑鼠滑過a鏈接時，滿足:link和:hover兩個偽類，要改變a標簽的顏色，就必須將:hover偽類在:link偽類後面聲明；

當滑鼠點擊激活a鏈接時，同時滿足:link、:hover、:active三種狀態，要顯示a標簽激活時的樣式（:active），必須將:active聲明放到:link和:hover之後。因此得出LVHA這個順序。

這個順序能不能變？可以，但也只有:link和:visited可以交換位置，因為一個鏈接要麼訪問過要麼沒訪問過，不可能同時滿足，也就不存在覆蓋的問題。

在組件中的應用

目前的前端開發為了增加開發效率，會對常用組件進行封裝，此外，組件還會添加一些必要的結構樣式。但是業務的設計文稿中可不一定按照預先寫好的默認樣式，需要在開發業務時根據組件的DOM結構修改默認樣式，此時會出現樣式不生效的問題。

例如下面的結構，如果對Title直接增加樣式類，則肯定不會生效，因為Title的DOM結構為兩層(組件樣式定義規定不能使用ID選擇器，且類選擇器滿足最小標記原則)），故樣式最多為0,0,2,x。因此，樣式多層標記就可提高自定義樣式的優先順序，例如下方的SCSS寫法。

<Pageclass="test"><Headerclass="test__header"><Navbar><Titleclass="test__header--title">Toolbar</Title></Navbar></Header><Content></Content></Page>

.test{.test__header{.test__header--title{height:100px;}}}

此外，對於Page組件的樣式標記策略推薦使用 金字塔形(樹形) ，比如上面的SCSS書寫，這樣可以保證內部自定義樣式不會受到外部干擾，減少不必要的麻煩。

鏈接：https://www.jianshu.com/p/1c4e639ff7d5

3. 優先順序調度演算法

思路都完全給你了，只要你敲敲代碼你都不幹，看你畢業找不到工作

4. 動態優先順序調度演算法

給你兩個例子，第一個：http://dev.csdn.net/article/53/53415.shtm

第二個：

#include "stdio.h"
#include <STDLIB.H>
#include <CONIO.H>
#define getpch(type) (type*)malloc(sizeof(type))
#define NULL 0
struct pcb { /* 定義進程式控制制塊PCB */
char name[10];
char state;
int super;
int ntime;
int rtime;
struct pcb* link;
}*ready=NULL,*p;
typedef struct pcb PCB;
sort() /* 建立對進程進行優先順序排列函數*/
{
PCB *first, *second;
int insert=0;
if((ready==NULL)||((p->super)>(ready->super))) /*優先順序最大者,插入隊首*/
{
p->link=ready;
ready=p;
}
else /* 進程比較優先順序,插入適當的位置中*/
{
first=ready;
second=first->link;
while(second!=NULL)
{
if((p->super)>(second->super)) /*若插入進程比當前進程優先數大,*/
{ /*插入到當前進程前面*/
p->link=second;
first->link=p;
second=NULL;
insert=1;
}
else /* 插入進程優先數最低,則插入到隊尾*/
{
first=first->link;
second=second->link;
}
}
if(insert==0) first->link=p;
}
}

input() /* 建立進程式控制制塊函數*/
{
int i,num;
//clrscr(); /*清屏*/
printf("\n 請輸入進程號?");
scanf("%d",&num);
for(i=0;i<NUM;I++) scanf(?%s?,p- 輸入進程名:?); printf(?\n p="getpch(PCB);" 進程號No.%d:\n?,i); {>name);
printf("\n 輸入進程優先數:");
scanf("%d",&p->super);
printf("\n 輸入進程運行時間:");
scanf("%d",&p->ntime);
printf("\n");
p->rtime=0;p->state='w';
p->link=NULL;
sort(); /* 調用sort函數*/
}
}
int space()
{
int l=0; PCB* pr=ready;
while(pr!=NULL)
{
l++;
pr=pr->link;
}
return(l);
}

disp(PCB * pr) /*建立進程顯示函數,用於顯示當前進程*/
{
printf("\n qname \t state \t super \t ndtime \t runtime \n");
printf("|%s\t",pr->name);
printf("|%c\t",pr->state);
printf("|%d\t",pr->super);
printf("|%d\t",pr->ntime);
printf("|%d\t",pr->rtime);
printf("\n");
}

check() /* 建立進程查看函數 */
{
PCB* pr;
printf("\n **** 當前正在運行的進程是:%s",p->name); /*顯示當前運行進程*/
disp(p);
pr=ready;
printf("\n ****當前就緒隊列狀態為:\n"); /*顯示就緒隊列狀態*/
while(pr!=NULL)
{
disp(pr);
pr=pr->link;
}
}

destroy() /*建立進程撤消函數(進程運行結束,撤消進程)*/
{
printf("\n 進程 [%s] 已完成.\n",p->name);
free(p);
}
running() /* 建立進程就緒函數(進程運行時間到,置就緒狀態*/
{
(p->rtime)++;
if(p->rtime==p->ntime)
destroy(); /* 調用destroy函數*/
else
{
(p->super)--;
p->state='w';
sort(); /*調用sort函數*/
}
}

main() /*主函數*/
{
int len, h=0;
char ch;
input();
len=space();
while((len!=0)&&(ready!=NULL))
{
ch=getchar();
h++;
printf("\n The execute number:%d \n",h);
p=ready;
ready=p->link;
p->link=NULL;
p->state='R';
check();
running();
printf("\n 按任一鍵繼續......");
ch=getchar();
}
printf("\n\n 進程已經完成.\n");
ch=getchar();
}

5. 非搶占式的靜態優先順序調度演算法 是什麼

非搶占式的靜態優先順序調度演算法是指：根據系統的資源分配策略所規定的資源分配演算法。
對於不同的的系統和系統目標，通常採用不同的調度演算法，例如，在批處理系統中，為了照顧為數眾多的段作業，應採用短作業優先的調度演算法；又如在分時系統中，為了保證系統具有合理的響應時間，應當採用輪轉法進行調度。
目前存在的多種調度演算法中，有的演算法適用於作業調度，有的演算法適用於進程調度；但也有些調度演算法既可以用於作業調度，也可以用於進程調度。

6. 優先順序調度演算法是什麼

優先順序演算法是指在進程創建時先確定一個初始優先數，以後在進程運行中隨著進程特性的改變不斷修改優先數，這樣，由於開始優先數很低而得不到CPU的進程，就能因為等待時間的增長而優先數變為最高而得到CPU運行。

7. 先來先服務調度演算法。 優先順序調度演算法。 短作業優先調度演算法 輪轉調度演算法 響應比高優先調度演算法

你試一下

#include<stdio.h>
//using namespace std;
#define MAX 10
struct task_struct
{
char name[10]; /*進程名稱*/
int number; /*進程編號*/
float come_time; /*到達時間*/
float run_begin_time; /*開始運行時間*/
float run_time; /*運行時間*/
float run_end_time; /*運行結束時間*/
int priority; /*優先順序*/
int order; /*運行次序*/
int run_flag; /*調度標志*/
}tasks[MAX];
int counter; /*實際進程個數*/
int fcfs(); /*先來先服務*/
int ps(); /*優先順序調度*/
int sjf(); /*短作業優先*/
int hrrn(); /*響應比高優先*/
int pinput(); /*進程參數輸入*/
int poutput(); /*調度結果輸出*/

void main()
{ int option;
pinput();
printf("請選擇調度演算法（0~4）:\n");
printf("1.先來先服務\n");
printf("2.優先順序調度\n");
printf(" 3.短作業優先\n");
printf(" 4.響應比高優先\n");
printf(" 0.退出\n");
scanf("%d",&option);
switch (option)
{case 0:
printf("運行結束。\n");
break;
case 1:
printf("對進程按先來先服務調度。\n\n");
fcfs();
poutput();
break;
case 2:
printf("對進程按優先順序調度。\n\n");
ps();
poutput();
break;
case 3:
printf("對進程按短作業優先調度。\n\n");
sjf();
poutput();
break;
case 4:
printf("對進程按響應比高優先調度。\n\n");
hrrn();
poutput();
break;
}
}
int fcfs() /*先來先服務*/
{
float time_temp=0;
inti;
intnumber_schel;
time_temp=tasks[0].come_time;
for(i=0;i<counter;i++)
{
tasks[i].run_begin_time=time_temp;
tasks[i].run_end_time=tasks[i].run_begin_time+tasks[i].run_time;
tasks[i].run_flag=1;
time_temp=tasks[i].run_end_time;
number_schel=i;
tasks[number_schel].order=i+1;
}
return 0;
}

int ps() /*優先順序調度*/
{
float temp_time=0;
inti=0,j;
intnumber_schel,temp_counter;
intmax_priority;
max_priority=tasks[i].priority;
j=1;
while((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].priority>tasks[i].priority)
{
max_priority=tasks[j].priority;
i=j;
}
j++;
} /*查找第一個被調度的進程*/
/*對第一個被調度的進程求相應的參數*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
max_priority=0;
for(j=0;j<counter;j++)
{if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if (tasks[j].priority>max_priority)
{
max_priority=tasks[j].priority;
number_schel=j;
}
} /*查找下一個被調度的進程*/
/*對找到的下一個被調度的進程求相應的參數*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;

}return 0;
}

int sjf() /*短作業優先*/
{
float temp_time=0;
inti=0,j;
intnumber_schel,temp_counter;
float run_time;
run_time=tasks[i].run_time;
j=1;
while((j<counter)&&(tasks[i].come_time==tasks[j].come_time))
{
if (tasks[j].run_time<tasks[i].run_time)
{
run_time=tasks[j].run_time;
i=j;
}
j++;
} /*查找第一個被調度的進程*/
/*對第一個被調度的進程求相應的參數*/
number_schel=i;
tasks[number_schel].run_begin_time=tasks[number_schel].come_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].order=1;
temp_counter=1;
while (temp_counter<counter)
{
for(j=0;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
{run_time=tasks[j].run_time;number_schel=j;break;}
}

for(j=0;j<counter;j++)
{if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
if(tasks[j].run_time<run_time)
{run_time=tasks[j].run_time;
number_schel=j;
}
}
/*查找下一個被調度的進程*/
/*對找到的下一個被調度的進程求相應的參數*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
tasks[number_schel].run_flag=1;
temp_time=tasks[number_schel].run_end_time;
temp_counter++;
tasks[number_schel].order=temp_counter;
}return 0;
}

int hrrn() /*響應比高優先*/
{ int j,number_schel,temp_counter;
float temp_time,respond_rate,max_respond_rate;
/*第一個進程被調度*/
tasks[0].run_begin_time=tasks[0].come_time;
tasks[0].run_end_time=tasks[0].run_begin_time+tasks[0].run_time;
temp_time=tasks[0].run_end_time;
tasks[0].run_flag=1;
tasks[0].order=1;
temp_counter=1;
/*調度其他進程*/
while(temp_counter<counter)
{
max_respond_rate=0;
for(j=1;j<counter;j++)
{
if((tasks[j].come_time<=temp_time)&&(!tasks[j].run_flag))
{respond_rate=(temp_time-tasks[j].come_time)/tasks[j].run_time;
if (respond_rate>max_respond_rate)
{
max_respond_rate=respond_rate;
number_schel=j;
}
}
} /*找響應比高的進程*/
tasks[number_schel].run_begin_time=temp_time;
tasks[number_schel].run_end_time=tasks[number_schel].run_begin_time+tasks[number_schel].run_time;
temp_time=tasks[number_schel].run_end_time;
tasks[number_schel].run_flag=1;
temp_counter+=1;
tasks[number_schel].order=temp_counter;
}
return 0;
}
int pinput() /*進程參數輸入*/
{ int i;
printf("please input the processcounter:\n");
scanf("%d",&counter);

for(i=0;i<counter;i++)
{printf("******************************************\n");
printf("please input the process of %d th :\n",i+1);
printf("please input the name:\n");
scanf("%s",tasks[i].name);
printf("please input the number:\n");
scanf("%d",&tasks[i].number);
printf("please input the come_time:\n");
scanf("%f",&tasks[i].come_time);
printf("please input the run_time:\n");
scanf("%f",&tasks[i].run_time);
printf("please input the priority:\n");
scanf("%d",&tasks[i].priority);
tasks[i].run_begin_time=0;
tasks[i].run_end_time=0;
tasks[i].order=0;
tasks[i].run_flag=0;
}
return 0;
}
int poutput() /*調度結果輸出*/
{
int i;
float turn_round_time=0,f1,w=0;
printf("name number come_time run_timerun_begin_time run_end_time priority order turn_round_time\n");
for(i=0;i<counter;i++)
{
f1=tasks[i].run_end_time-tasks[i].come_time;
turn_round_time+=f1;
w+=(f1/tasks[i].run_time);
printf(" %s, %d, %5.3f, %5.3f, %5.3f, %5.3f, %d, %d,%5.3f\n",tasks[i].name,tasks[i].number,tasks[i].come_time,tasks[i].run_time,tasks[i].run_begin_time,tasks[i].run_end_time,tasks[i].priority,tasks[i].order,f1);
}
printf("average_turn_round_timer=%5.2f\n",turn_round_time/counter);
printf("weight_average_turn_round_timer=%5.2f\n",w/counter);
return 0;
}

8. 進程調度方案設計 實現一個基本動態優先順序的調度演算法

前兩天做操作系統作業的時候學習了一下幾種進程調度演算法，在思考和討論後，有了一些自己的想法，現在就寫出來，跟大家討論下。，或者說只有有限的CPU資源，當系統中有多個進程處於就緒狀態，要競爭CPU資源時，操作系統就要負責完成如何分配資源的任務。在操作系統中，由調度程序來完成這一選擇分配的工作，調度程序所使用的演算法即是調度演算法。調度演算法需要考慮的指標主要有盡量保證CPU資源分配的公平性；按照一定策略強制執行演算法調度；平衡整個計算機系統，盡量保持各個部分都處於忙碌狀態。而根據系統各自不同的特點和要求，調度演算法又有一些側重點和目標不同，因此，演算法按照系統差異主要分為三大類：批處理系統中的調度演算法，代表調度演算法有：先來先服務、最短作業優先、最短剩餘時間優先。互動式系統中的調度演算法，代表調度演算法有：輪轉調度、優先順序調度、多級隊列、最短進程優先、保證調度、彩票調度、公平分享調度。實時系統中的調度演算法，代表調度演算法有：速率單調調度、最早最終時限優先調度。下面就上述提到的調度演算法中挑出幾個進行重點分析：保證調度保證調度是指利用演算法向用戶做出明確的性能保證，然後盡力按照此保證實現CPU的資源分配。利用這種演算法，就是定一個進程佔用CPU的時間的標准，然後按照這個標准去比較實際佔用CPU的時間，調度進程每次使離此標准最遠的進程得到資源，不斷滿足離所保證的標准最遠的進程，從而平衡資源分配滿足這個標準的要求。保證調度演算法的優點是：能很好的保證進程公平的CPU份額，當系統的特點是：進程的優先順序沒有太大懸殊，所制定的保證標准差異不大，各個進程對CPU的要求較為接近時，比如說系統要求n個進程中的每個進程都只佔用1/n的CPU資源，利用保證調度可以很容易的實現穩定的CPU分配要求。但缺點是，這種情況太過理想，當系統的各個進程對CPU要求的緊急程度不同，所制定的保證較為復雜的時候，這個演算法實現起來比較困難。彩票調度彩票調度這種演算法的大意是指向進程提供各種系統資源如CPU資源的彩票，當系統需要做出調度決策時，隨機抽出一張彩票，由此彩票的擁有者獲得資源。在彩票調度系統中，如果有一個新的進程出現並得到一些彩票，那麼在下一次的抽獎中，該進程會有同它持有彩票數量成正比例的機會贏得獎勵。進程持有的彩票數量越多，則被抽中的可能性就越大。調度程序可以通過控制進程的彩票持有數量來進行調度。彩票調度有很多優點：首先，它很靈活，系統增加分給某個進程的彩票數量，就會大大增加它佔用資源的可能性，可以說，彩票調度的反應是迅速的，而快速響應需求正是互動式系統的一個重要要求。其次，彩票調度演算法中，進程可以交換彩票，這個特點可以更好的保證系統的平衡性，使其各個部分都盡可能的處於忙碌狀態。而且利用彩票調度還可以解決許多別的演算法很難解決的問題，例如可以根據特定的需要大致成比例的劃分CPU的使用。速率單調調度速率單調調度演算法是一種可適用於可搶占的周期性進程的經典靜態實時調度演算法。當實時系統中的進程滿足：每個周期性進程必須在其周期內完成，且進程之間沒有相互依賴的關系，每個進程在一次突發中需要相同的CPU時間量，非周期的進程都沒有最終時限四個條件時，並且為了建模方便，我們假設進程搶占即刻發生沒有系統開銷，可以考慮利用速率單調演算法。速率單調調度演算法是將進程的速率（按照進程周期所算出的每秒響應的次數）賦為優先順序，則保證了優先順序與進程速率成線性關系，這即是我們所說的速率單調。調度程序每次運行優先順序最高的，只要優先順序較高的程序需要運行，則立即搶占優先順序低的進程，而優先順序較低的進程必須等所有優先順序高於它的進程結束後才能運行。速率單調調度演算法可以保證系統中最關鍵的任務總是得到調度，但是缺點是其作為一種靜態演算法，靈活性不夠好，當進程數變多，系統調度變得復雜時，可能不能較好的保證進程在周期內運行。最早最終時限優先調度最早最終時限優先調度演算法是一個動態演算法，不要求進程是周期性的，只要一個進程需要CPU時間，它就宣布它的到來時間和最終時限。調度程序維持一個可運行的進程列表，按最終時限排序，每次調度一個最終時限最早的進程得到CPU 。當新進程就緒時，系統檢查其最終時限是否在當前運行的進程結束之前，如果是，則搶占當前進程。由於是動態演算法，最早最終優先調度的優點就是靈活，當進程數不超過負載時，資源分配更優，但也同樣由於它的動態屬性，進程的優先順序都是在不斷變化中的，所以也沒有哪個進程是一定可以保證滿足調度的，當進程數超過負載時，資源分配合理度會急速下降，所以不太穩定。

9. 靜態搶占式優先順序調度演算法是如何進行的

按照優先順序值的大小進行調度，選擇優先順序值大的作業優先調度。搶占式是指如果進入的作業的優先順序數大於當前正在執行的作業的優先順序數，就執行進入的作業，搶佔了當前正在執行的作業的資源。
按照到達時間將作業放入就緒隊列，當前作業執行過程中有作業進入，根據作業的優先順序值進行判斷，如果進入的作業的優先順序值小於或等於當前執行的作業的優先順序值，繼續執行當前作業；如果進入的作業的優先順序值大於當前執行的作業的優先順序值，將資源給進入的作業，當前的作業就放入就緒隊列隊尾，此時還需要的服務時間為原服務時間-進入的作業的到達時間。之後，每到達一個作業就與當前執行的作業進行優先順序值比較，優先順序值大的優先執行。當當前執行的作業執行結束後，比較就緒隊列中的作業的優先順序值，優先順序值大的優先執行。如此執行，直到就緒隊列為空，結束調度。

10. 作業調度演算法的優先順序法

優先順序演算法（Priority Scheling）是多級隊列演算法的改進，平衡各進程對響應時間的要求。適用於作業調度和進程調度，可分成搶先式和非搶先式。 作業調度中的靜態優先順序大多按以下原則確定：
由用戶自己根據作業的緊急程度輸入一個適當的優先順序。
由系統或操作員根據作業類型指定優先順序。
系統根據作業要求資源情況確定優先順序。
進程的靜態優先順序的確定原則：
按進程的類型給予不同的優先順序。
將作業的情態優先順序作為它所屬進程的優先順序。 進程的動態優先順序一般根據以下原則確定：
根據進程佔用有CPU時間的長短來決定。
根據就緒進程等待CPU的時間長短來決定。