本篇文章進行操作系統(tǒng)中進程狀態(tài)的學(xué)習(xí)！??！

1、進程狀態(tài)

1.1、概念

在學(xué)習(xí)OS中的進程狀態(tài)時，書上的描述為了在Linux、Windows、Android中都能說的通，往往加深了理解的難度

我們可以先學(xué)習(xí)具體的Linux進程狀態(tài)，然后再介紹然后再介紹OS學(xué)科的狀態(tài)如何理解

操作系統(tǒng)是計算機中的一門“哲學(xué)”，要考慮很多情況

貼幾張不同的進程狀態(tài)圖

1.2、具體的進程狀態(tài)

1. 具體的進程狀態(tài)可以分為四種：

運行態(tài)：進程只要被加載到運行隊列中

如何理解進程被加載到運行隊列中？

運行隊列也是一個對象，也可以通過描述再組織進行管理

運行隊列的屬性其中有PCB指針，可以通過隊列的性質(zhì)或復(fù)雜的數(shù)據(jù)結(jié)構(gòu)進行管理

調(diào)度器的主要作用是在就緒隊列中選擇優(yōu)先級最高的任務(wù)運行，如果優(yōu)先級最高的任務(wù)不止一個，則選擇隊頭的任務(wù)運行

當(dāng)運行隊列中的進程被調(diào)度時，CPU會執(zhí)行該進程的代碼

2. 終止態(tài)：進程已經(jīng)終止，但還存在，只是永遠不運行了，隨時等待被釋放

進程都已經(jīng)終止了，為什么不立刻釋放資源，而要維護一個終止態(tài)呢？

因為釋放進程的資源需要時間

CPU不可能一直盯著這個進程，可能還會在做其他事情，所以要維護一個終止態(tài)

例子：比如你去吃飯，吃完后，叫老板結(jié)賬，老板可能沒回應(yīng)你，他可能在給別人點餐

3. 阻塞態(tài)：進程在等待某種資源時(非CPU資源)，資源沒有就緒的時候，該進程會到對應(yīng)的資源等待隊列中進行排隊，該進程的代碼并沒有運行，就叫做"阻塞態(tài)"

一個進程在被CPU執(zhí)行的時候，用的不僅僅是CPU的資源

進程可能申請更多的資源，如：磁盤、網(wǎng)卡、顯卡、顯示器資源和聲卡資源等等…

申請對應(yīng)的資源無法滿足時，是需要排隊的，比如：CPU資源在運行隊列中排隊

申請其他慢設(shè)備的資源在對應(yīng)的隊列中進行排隊

4. 掛起態(tài)：當(dāng)內(nèi)存不足時，OS會將短期內(nèi)不會被調(diào)度的進程的數(shù)據(jù)和代碼挪動到磁盤中的swap分區(qū)，當(dāng)內(nèi)存足夠時，會重新加載到內(nèi)存中

1.3、Linux進程狀態(tài)

Linux內(nèi)核源代碼中的狀態(tài)

/*
* The task state array is a strange "bitmap" of
* reasons to sleep. Thus "running" is zero, and
* you can test for combinations of others with
* simple bit tests.
*/
static const char * const task_state_array[] = 
{
	"R (running)", /* 0 */
	"S (sleeping)", /* 1 */
	"D (disk sleep)", /* 2 */
	"T (stopped)", /* 4 */
	"t (tracing stop)", /* 8 */
	"X (dead)", /* 16 */
	"Z (zombie)", /* 32 */
};

1.3.1、R運行狀態(tài)（運行態(tài)）

R (running)運行狀態(tài)：進程是在運行中或在運行隊列中

R狀態(tài)一般是看不出來的，因為CPU的運算速度非?？欤?dāng)你運行程序時，CPU就已經(jīng)執(zhí)行結(jié)束

比如在死循環(huán)中打印hello world，進程狀態(tài)一般為"S"，因為CPU太快了

CPU一般在等待顯示器資源就緒，所以狀態(tài)一直為S

[lyh_sky@localhost lesson11]$ ls
makefile  test  test.cpp
[lyh_sky@localhost lesson11]$ cat test.cpp 
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
using namespace std;
int main()
{
    while (1)
    {
        cout << "hello world!!!" << endl;
        sleep(3);
    }
    return 0;
}
[lyh_sky@localhost lesson11]$ cat makefile 
test:test.cpp
	g++ test.cpp -o test
.PHONY:clean
clean:
	rm -rf test
[lyh_sky@localhost lesson11]$ ./test 

通過不斷刷新ps指令來查看進程狀態(tài)的變化：while :; do ps ajx | head -1 && ps ajx | grep ‘test’ | grep -v grep; sleep 2; echo “#############################################”; done

可以通過不斷的死循環(huán)來讓CPU一直不斷的工作，因為死循環(huán)沒有訪問外設(shè)資源

[lyh_sky@localhost lesson11]$ ls
makefile  test  test.cpp
[lyh_sky@localhost lesson11]$ cat test.cpp 
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
using namespace std;
int main()
{
    while (1)
    {
    }
    return 0;
}
[lyh_sky@localhost lesson11]$ cat makefile 
test:test.cpp
	g++ test.cpp -o test
.PHONY:clean
clean:
	rm -rf test
[lyh_sky@localhost lesson11]$ ./test 

1.3.2、S/D睡眠狀態(tài)（阻塞態(tài)）

S (sleeping)睡眠狀態(tài)：意味著進程在等待事件完成

這里的睡眠也叫做：可中斷睡眠（淺睡眠），因為它可以通過指令進行中斷

可以使用 kill 【-9】 【進程PID】進行中斷

睡眠狀態(tài)是：該進程申請的資源已經(jīng)被其他進程使用，該進程在對應(yīng)的“資源等待隊列中進行等待，進程中的代碼沒有執(zhí)行

[lyh_sky@localhost lesson11]$ ls
makefile  test  test.cpp
[lyh_sky@localhost lesson11]$ cat test.cpp 
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
using namespace std;
int main()
{
    while (1)
    {
        cout << "hello world!!!" << endl;
        sleep(3);
    }
    return 0;
}
[lyh_sky@localhost lesson11]$ cat makefile 
test:test.cpp
	g++ test.cpp -o test
.PHONY:clean
clean:
	rm -rf test
[lyh_sky@localhost lesson11]$ ./test 

D磁盤休眠狀態(tài)（Disk sleep）

D狀態(tài)也叫不可中斷睡眠狀態(tài)（uninterruptible sleep），在這個狀態(tài)的進程通常會等待IO的結(jié)束

D狀態(tài)不能通過指令進行中斷，必須等它由D狀態(tài)變成S狀態(tài)時才能殺死

經(jīng)過上圖可以發(fā)現(xiàn)，如果堆磁盤進行讀寫時，發(fā)生中斷，會導(dǎo)致嚴(yán)重的問題

所以才有了D狀態(tài)，D狀態(tài)就算是OS也不能對其進行釋放

D狀態(tài)不好模擬，但可以使用"dd指令"進行模擬

1.3.3、T/t停止?fàn)顟B(tài)

T停止?fàn)顟B(tài)（stopped）：

可以通過發(fā)送 SIGSTOP 信號或快捷鍵【ctrl+z】給進程來停止（T）進程

這個被暫停的進程可以通過發(fā)送 SIGCONT 信號讓進程繼續(xù)運行

[lyh_sky@localhost lesson11]$ ls
makefile  test  test.cpp
[lyh_sky@localhost lesson11]$ cat test.cpp 
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
using namespace std;
int main()
{
    while (1)
    {
        cout << getpid() << endl;
        sleep(2);
    }
    return 0;
}
[lyh_sky@localhost lesson11]$ cat makefile 
test:test.cpp
	g++ test.cpp -o test
.PHONY:clean
clean:
	rm -rf test
[lyh_sky@localhost lesson11]$ ./test 

可以通過kill 【-19】 【進程PID】將指定進程發(fā)生停止運行信號

kill 【-18】【進程PID】可以恢復(fù)重新運行

還有一種t (tracing stop)狀態(tài)：針對gdb調(diào)試的狀態(tài)

[lyh_sky@localhost lesson11]$ ls
makefile  test  test.cpp
[lyh_sky@localhost lesson11]$ cat test.cpp 
#include <iostream>
#include <unistd.h>
#include <sys/types.h>
using namespace std;
int main()
{
    while (1)
    {
        cout << getpid() << endl;
        sleep(2);
    }
    return 0;
}
[lyh_sky@localhost lesson11]$ cat makefile 
test:test.cpp
	g++ test.cpp -o test -g
.PHONY:clean
clean:
	rm -rf test
[lyh_sky@localhost lesson11]$ make
g++ test.cpp -o test -g
[lyh_sky@localhost lesson11]$ gdb test

1.3.3、X死亡狀態(tài)

X死亡狀態(tài)（dead）：這個狀態(tài)只是一個返回狀態(tài)，你不會在任務(wù)列表里看到這個狀態(tài)

1.3.4、Z(zombie)僵尸進程

概念：

注意：僵尸進程是不能被殺死的，因為已經(jīng)是僵尸了，不能再死第二次！??！

當(dāng)一個進程退出的時候，一般不會直接進入X狀態(tài)(死亡，資源可以立馬被會回收)，而是進入Z狀態(tài)

僵死狀態(tài)（Zombies）是一個比較特殊的狀態(tài)。當(dāng)進程退出并且父進程（使用wait()系統(tǒng)調(diào)用）沒有讀取到子進程退出的返回代碼時就會產(chǎn)生僵死(尸)進程

僵死進程會以終止?fàn)顟B(tài)保持在進程表中，并且會一直在等待父進程讀取退出狀態(tài)代碼

只要子進程退出，父進程還在運行，但父進程沒有讀取子進程狀態(tài)，子進程進入Z狀態(tài)

進程被創(chuàng)建出來是因為用戶有任務(wù)要交給它執(zhí)行，當(dāng)進程退出的時候，我們不知道這個進程完成的怎么樣了，一般需要將進程的執(zhí)行結(jié)果告知給父進程和OS

模擬Z狀態(tài)：創(chuàng)建子進程，子進程退出，父進程不退出(還在運行)，子進程退出之后的狀態(tài)就是Z

[lyh_sky@localhost lesson11]$ cat test.cpp 
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
using namespace std;
int main()
{
    pid_t id = fork();
    int cnt = 3;
    if (id == 0)
    {
        while (cnt)
        {
            cout << "我是子進程，我還有" << cnt-- << "秒時間結(jié)束" << endl;
            sleep(1);
        }
        cout << "進入僵尸狀態(tài)" << endl;
        // 結(jié)束子進程，并且返回0
        exit(0);
    }
    else
    {
        while (1)
        {}
    }
    return 0;
}
[lyh_sky@localhost lesson11]$ cat makefile 
test:test.cpp
	g++ test.cpp -o test -g
.PHONY:clean
clean:
	rm -rf test
[lyh_sky@localhost lesson11]$ ./test 

僵尸進程危害：

如果沒有人回收子進程的僵尸，該狀態(tài)會一直被維！該進程的相關(guān)資源(task_struct)不會被釋放

那一個父進程創(chuàng)建了很多子進程，就是不回收，就會造成內(nèi)存資源的浪費！因為數(shù)據(jù)結(jié)構(gòu)對象本身就要占用內(nèi)存，想想C中定義一個結(jié)構(gòu)體變量，是要在內(nèi)存的某個位置進行開辟空間！

這樣就會造成內(nèi)存泄漏！??！

2、孤兒進程

init進程：它是內(nèi)核啟動的第一個用戶級進程

父進程如果提前退出，那么子進程后退出，進入Z之后，那該如何處理呢？

父進程先退出，子進程就稱之為“孤兒進程”

孤兒進程被1號init進程領(lǐng)養(yǎng)，當(dāng)然要有init進程回收嘍

[lyh_sky@localhost lesson11]$ cat test.cpp 
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
using namespace std;
int main()
{
    pid_t id = fork();
    int cnt = 3;
    if (id != 0)
    {
        while (cnt)
        {
            cout << "我是父進程，我還有" << cnt-- << "秒時間結(jié)束" << endl;
            sleep(1);
        }
        cout << "父進程退出" << endl;
        exit(0);
    }
    else
    {
        while (1)
        {}
    }
    return 0;
}
[lyh_sky@localhost lesson11]$ cat makefile 
test:test.cpp
	g++ test.cpp -o test -g
.PHONY:clean
clean:
	rm -rf test
[lyh_sky@localhost lesson11]$ ./test 

3、Linux進程優(yōu)先級 

3.1、優(yōu)先級概念

進程優(yōu)先級和權(quán)限的區(qū)別？

進程優(yōu)先級是：進程獲取外設(shè)資源的先后順序問題

權(quán)限是：擁有者、所屬組和other是否可以進行讀寫執(zhí)行操作

它們的區(qū)別是：在學(xué)校中，我們?nèi)コ燥?，食堂分教師和學(xué)生，我們不能去教師食堂打飯，這就是權(quán)限。我們打飯時，需要排隊，排在前面可以先打到飯，后面的也一樣可以打到飯，這就是優(yōu)先級

概念：

cpu資源分配的先后順序，就是指進程的優(yōu)先權(quán)（priority）

優(yōu)先權(quán)高的進程有優(yōu)先執(zhí)行權(quán)利。配置進程優(yōu)先權(quán)對多任務(wù)環(huán)境的linux很有用，可以改善系統(tǒng)性能

還可以把進程運行到指定的CPU上，這樣一來，把不重要的進程安排到某個CPU，可以大大改善系統(tǒng)整體性能

為什么要存在進程優(yōu)先級呢？？？

排隊的本質(zhì)就是確認(rèn)進程的優(yōu)先級

內(nèi)存里面永遠都是進程占大多數(shù)，而資源是少數(shù)（外設(shè)：磁盤、網(wǎng)卡、顯卡…）

進程競爭資源是常態(tài)，OS要確認(rèn)進程的先后循序，不然就亂套了

3.2、Linux下進程優(yōu)先級的操作

使用【ps -al】指令查看進程更多的屬性（包含進程優(yōu)先級）：

top指令

進入top后按“r”–>輸入進程PID–>輸入nice值

[lyh_sky@localhost lesson11]$ ls
makefile  test  test.cpp
[lyh_sky@localhost lesson11]$ cat test.cpp 
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
using namespace std;
int main()
{
    while (1)
    {
        cout << "hello world!!!" << endl;
        sleep(2);
    }
    return 0;
}
[lyh_sky@localhost lesson11]$ cat makefile 
test:test.cpp
	g++ test.cpp -o test -g
.PHONY:clean
clean:
	rm -rf test
[lyh_sky@localhost lesson11]$ ./test 

我們很容易注意到其中的幾個重要信息，有下：

• UID : 代表執(zhí)行者的身份
• PID : 代表這個進程的代號
• PPID ：代表這個進程是由哪個進程發(fā)展衍生而來的，亦即父進程的代號
• PRI ：代表這個進程可被執(zhí)行的優(yōu)先級，其值越小越早被執(zhí)行
• NI ：代表這個進程的nice值

3.3、PRI 和 NI

PRI也還是比較好理解的，即進程的優(yōu)先級，或者通俗點說就是程序被CPU執(zhí)行的先后順序，此值越小進程的優(yōu)先級別越高

NI就是nice值，其表示進程可被執(zhí)行的優(yōu)先級的修正數(shù)值

PRI值越小越快被執(zhí)行，那么加入nice值后，將會使得PRI變?yōu)椋?PRI(new) = PRI(old) + nice

當(dāng)nice值為負值的時候，那么該程序?qū)?yōu)先級值將變小，即其優(yōu)先級會變高，則其越快被執(zhí)行

調(diào)整進程優(yōu)先級，在Linux下，就是調(diào)整進程nice值

nice其取值范圍是-20至19，一共40個級別，調(diào)整NI時，會重新變成初始值80，然后+NI值

例如PRI：70 NI：-10，把NI更改成10時，PRI = 80 + 10 = 90

在root用戶下，使用top指令修改進程優(yōu)先級：

[lyh_sky@localhost lesson11]$ ls
makefile  test  test.cpp
[lyh_sky@localhost lesson11]$ cat test.cpp 
#include <iostream>
#include <cstdlib>
#include <unistd.h>
#include <sys/types.h>
using namespace std;
int main()
{
    while (1)
    {
        cout << "hello world!!!" << endl;
        cout << "我的pid是: " << getpid() << endl;
        sleep(2);
    }
    return 0;
}
[lyh_sky@localhost lesson11]$ cat makefile 
test:test.cpp
	g++ test.cpp -o test -g
.PHONY:clean
clean:
	rm -rf test
[lyh_sky@localhost lesson11]$ ./test 

進入top指令后輸入r，然后回車，然后輸入需要修改進程優(yōu)先級的pid

輸入pid后回車，接著輸入NI值，就能修改進程優(yōu)先級了

3.4、PRI vs NI

需要強調(diào)一點的是，進程的nice值不是進程的優(yōu)先級，他們不是一個概念，但是進程nice值會影響到進程的優(yōu)先級變化

可以理解nice值是進程優(yōu)先級的修正修正數(shù)據(jù)

4、其他概念

1. 競爭性：系統(tǒng)進程數(shù)目眾多，而CPU資源只有少量，甚至1個，所以進程之間是具有競爭屬性的。為了高效完成任務(wù)，更合理競爭相關(guān)資源，便具有了優(yōu)先級

2. 獨立性：多進程運行，需要獨享各種資源，多進程運行期間互不干擾

比如：我們在下載東西時，同時打開瀏覽器進行瀏覽，當(dāng)瀏覽器掛掉了，是不會影響下載的，反之下載掛掉了，也不會影響瀏覽器

進程具有獨立性，不會因為一個進程掛斷或者出現(xiàn)異常，而導(dǎo)致其他進程出現(xiàn)問題

3. 并行：多個進程在多個CPU下，分別同時進行運行，這稱之為并行

4. 并發(fā)：多個進程在一個CPU下采用進程切換的方式，在一段時間之內(nèi)，讓多個進程都得以推進，稱之為并發(fā)

操作系統(tǒng)，就是簡單的根據(jù)隊列來進行先后調(diào)度的嗎？有沒有可能突然來了一個優(yōu)先級更高的進程？

操作系統(tǒng)中有二種內(nèi)核，分為“搶占式內(nèi)核”和“非搶占式內(nèi)核”

當(dāng)正在運行的低優(yōu)先級進程，如果來了一個優(yōu)先級更高的進程，調(diào)度器會直接把正在執(zhí)行的進程從CPU上剝離，放上優(yōu)先級更高的進程，這就是“進程搶占”（搶占式內(nèi)核）

5. 進程上下文：進程在運行中產(chǎn)生的各種寄存器數(shù)據(jù)，就叫做進程的硬件上下文數(shù)據(jù)

當(dāng)進程被剝離：需要保存上下文數(shù)據(jù)

當(dāng)進程恢復(fù)的時候：需要將曾經(jīng)保存的 上下文數(shù)據(jù)恢復(fù)到寄存器中

總結(jié)

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。

最新評論