1、作業系統瞭解

　　現代的計算機系統主要是由一個或者多個處理器，主存，硬碟，鍵盤，滑鼠，顯示器，印表機，網路介面及其他輸入輸出裝置組成, 這些都是硬體裝置, 而作業系統就是負責呼叫這些硬體為使用者服務的.

　　作業系統位於計算機硬體與應用軟體之間，本質也是一個軟體. 

　　精簡的說的話，作業系統就是一個協調、管理和控制計算機硬體資源和軟體資源的控制程式。

2、作業系統發展中幾個比較重要的系統階段

　　多道程式系統

　　　　 多道程式設計技術，就是指允許多個程式同時進入記憶體並執行。即同時把多個程式放入記憶體，並允許它們交替在CPU中執行，它們共享系統中的各種硬、軟體資源。當一道程式因I/O請求而暫停執行時，CPU便立即轉去執行另一道程式。

　　　　特點: 空間複用：將記憶體分為幾部分，每個部分放入一個程式，這樣，同一時間記憶體中就有了多道程式.

　　　　　　  時間複用：當一個程式在等待I/O時，另一個程式可以使用cpu，如果記憶體中可以同時存放足夠多的作業，則cpu的利用率可以接近100%.

　　　　缺點: 空間複用：程式之間的記憶體沒有確切分割，不由作業系統控制。如果記憶體彼此不分割，則一個程式可以訪問另外一個程式的記憶體。

　　　　　　  時間複用：必須等某個程式出現I/O阻塞, cpu才會進行切換, 否則該程式一直佔用cpu資源. 

　　分時系統(互動式系統)

　　　　把處理機的執行時間分成很短的時間片，按時間片輪流把處理機分配給各聯機作業使用。若某個作業在分配給它的時間片內不能完成其計算，則該作業暫時中斷，把處理機讓給另一作業使用，等待下一輪時再繼續其執行。由於計算機速度很快，作業執行輪轉得很快，給每個使用者的印象是，好象他獨佔了一臺計算機。而每個使用者可以通過自己的終端向系統發出各種操作控制命令，在充分的人機互動情況下，完成作業的執行。

　　　　特點: 

　　　　　　（1）多路性。若干個使用者同時使用一臺計算機。微觀上看是各使用者輪流使用計算機；巨集觀上看是各使用者並行工作.

　　　　　　（2）互動性。使用者可根據系統對請求的響應結果，進一步向系統提出新的請求。這種能使使用者與系統進行人機對話的工作方式，又被稱為互動式系統.

　　　　　　（3）及時性。系統可對使用者的輸入及時作出響應.

　　　　　　（4）獨立性。使用者之間可以相互獨立操作，互不干擾。系統保證各使用者程式執行的完整性，不會發生相互混淆或破壞現象. 　　　　缺點:  　　　　　　計算機的效率變低 ( 分時系統的分時間片工作，在沒有遇到IO操作的時候就用完了自己的時間片被切走了，這樣的切換工作其實並沒有提高cpu的效率，反而使得計算機的效率降低了。為什麼下降了呢？因為CPU需要切換，並且記錄每次切換程式執行到了哪裡，以便下次再切換回來的時候能夠繼續之前的程式，雖然我們犧牲了一點效率，但是卻實現了多個程式共同執行的效果，這樣你就可以在計算機上一邊聽音樂一邊聊qq了 ) 。

3、什麼是程序

　　程序: 就是執行中的程式. 當cpu呼叫程式計算時才是一個程序.　

　　特點: 

　　　　動態性：程序的實質是程式在多道程式系統中的一次執行過程，程序是動態產生，動態消亡的　　

　　　　併發性：任何程序都可以同其他程序一起併發執行

　　　　獨立性：程序是一個能獨立執行的基本單位，同時也是系統分配資源和排程的獨立單位；

　　　　非同步性：由於程序間的相互制約，使程序具有執行的間斷性，即程序按各自獨立的、不可預知的速度向前推進

　　　　結構特徵：程序由程式、資料和程序控制塊三部分組成。

　　　　多個不同的程序可以包含相同的程式：一個程式在不同的資料集裡就構成不同的程序，能得到不同的結果；但是執行過程中，程式不能發生改變。

4、併發與並行

　　併發：是偽並行，即看起來是同時執行。單個cpu+多道技術就可以實現併發，（並行也屬於併發）

　　並行：並行：同時執行，只有具備多個cpu才能實現並行

　　記憶體中同時存入多道（多個）程式，cpu從一個程序快速切換到另外一個，使每個程序各自執行幾十或幾百毫秒，這樣，雖然在某一個瞬間，一個cpu只能執行一個任務，但在1秒內，cpu卻可以執行多個程序，這就給人產生了並行的錯覺，即偽並行，以此來區分多處理器作業系統的真正硬體並行（多個cpu共享同一個實體記憶體）

5、同步/非同步/阻塞/非阻塞

　　程式的三個狀態

　　　　就緒狀態: 當程序已分配到除CPU以外的所有必要的資源，只要獲得cpu便可立即執行，這時的程序狀態稱為就緒狀態。

　　　　執行/執行狀態: 當程序已獲得cup，其程式正在cpu上執行，此時的程序狀態稱為執行狀態。

　　　　阻塞狀態: 正在執行的程序，由於等待某個事件發生而無法執行時，便放棄cpu而處於阻塞狀態。引起程序阻塞的事件可有多種，例如，等待I/O完成、申請緩衝區不能滿足、等待信件(訊號)等。

　　

　　同步: 第一個程式執行完才執行第二個程式, 序列.

　　非同步: 不需要等待第一個程式結束, 就可以執行第二個程式. 

　　阻塞: 程式在等待某個指令之外不能做其他的事, 這個機制就是阻塞.

　　非阻塞: 程式在等待某個指令之外, 還能做其他的事情, 即非阻塞. 

　　同步阻塞: 程式被阻塞著, 除了等不能幹其他的事情, 效率最低.

　　非同步阻塞: 非同步操作是可以被阻塞的, 不過不是在處理訊息時阻塞, 而是在等待訊息通知時被阻塞, 效率較低.

　　同步非阻塞: 程式沒有阻塞, 但要在兩種不同的行為之間來回切換, 效率較低. 

　　非同步非阻塞: 可以幹其他的事情而且不會被阻塞.

6、建立程序的兩種方式

　　建立Process類的程序物件.

1 import os
 2 from multiprocessing import Process
 3 
 4 def func1(a):
 5     print(a)
 6     print("執行func1函式")
 7     print("子程序的程序號-----",os.getpid())
 8     print("子程序的父程序的程序號////////",os.getppid())       # 和主程序的程序號一樣
 9 
10 def func2():
11     print("執行func2函式")
12 
13 
14 
15 a = "123456"
16 if __name__ == '__main__':
17     # --------> 在windows下必須要寫的, 在建立子程序時, 系統會把當前模組內的所有程式碼複製一份到子程序中去,
18     # 加上 if __name__ == '__main__', 子程序執行時, __name__在子程序中為"__mp_main__", 不等於"__main__", 不會被執行. 
19 
20 
21 
22     p = Process(target=func1,args=(563,))     # 建立一個程序物件, args引數必須是一個元組的形式
23     p.start()       # 子程序執行start方法,並不是呼叫子程序, 而是告訴作業系統, 子程序建立好了, 可以讓cpu去呼叫子程序了
24 
25     print("主程序的程序號+++++",os.getpid())
26     print("執行到最後了")
27 
28 
29 
30 
31     print(a+"主程序",__name__)    # 放在  if __name__ == '__main__' 中, 只能執行一次
32 print(a+"子程序",__name__)   # 會被執行兩次

建立程序第一種方式

繼承Process類, 以類的方式建立程序.

1 from multiprocessing import Process
 2 
 3 class MyProcess(Process):
 4 
 5     def __init__(self,m):       # 想要傳參必須先繼承父類的__init__方法, 然後再封裝引數在物件中.
 6         super().__init__()
 7         self.m = m
 8 
 9     def run(self):          # 方法名一定是run(), 否則無意義.
10         print("執行run方法")
11         print(self.m)
12 
13 
14 
15 if __name__ == '__main__':
16 
17     p = MyProcess(360)       # 例項化自己定義的程序類
18     p.start()

建立程序的第二種方式

引數介紹：   1 group引數未使用，值始終為None

　　　　　　2 target表示呼叫物件，即子程序要執行的任務

　　　　　　3 name為子程序的名稱

 

　　　　　　4 args表示呼叫物件的位置引數元組，args=(1,2,'egon',)

　　　　　　5 kwargs表示呼叫物件的字典,kwargs={'name':'egon','age':18}

7、幾種方法

　　p.terminate() : 強制終止程序

　　p.is_alive() : 如果p還在執行,就返回True

　　p.join() : 等待子程序結束後主程序再結束. 

　　os.getpid() : 獲取該程序的程序號

　　os.getppid() : 獲取該程序父程序的程序號

　　p.pid: p程序的程序號

　　p.name: p程序的名字

1 import time
 2 from multiprocessing import Process
 3 
 4 class MyProcess(Process):
 5 
 6     def __init__(self,m):       # 想要傳參必須先繼承父類的__init__方法, 然後再封裝引數在物件中.
 7         super().__init__()
 8         self.m = m
 9 
10     def run(self):          # 方法名一定是run(), 否則無意義.
11         print("執行run方法")
12         print(self.m)
13         time.sleep(5)
14         print("看看terminate好使不")
15 
16 
17 
18 if __name__ == '__main__':
19 
20     p = MyProcess(360)       # 例項化自己定義的程序類
21     p.start()
22 
23     p.terminate()       # 關閉程序,不會立即關閉,有個等著作業系統去關閉這個程序的時間,所以is_alive立刻檢視的結果可能還是存活，但是稍微等一會，就被關掉了
24     print(p.is_alive())       # True
25     time.sleep(0.1)
26     print(p.is_alive())         # False

幾種方法演示

8、程序之間的資料是隔離的, 一般情況下不同程序間的資料是相互訪問不到的.

 

1 from multiprocessing import Process
 2 
 3 numb = 100
 4 class MyProcess(Process):
 5 
 6     def run(self):
 7         global numb
 8         numb += 100
 9         print("子程序的numb: ",numb)            # numb都是200, 非同步,每個子程序都開始搶佔cpu資源
10 
11 
12 
13 
14 if __name__ == '__main__':
15 
16     p_lst = []
17     for i in range(10):
18         p = MyProcess()
19         p.start()
20         p_lst.append(p)         # 建立10個程序並加進列表裡
21     for p in p_lst:
22         p.join()         # 等所有的程序都跑完了再走主程序
23 
24     print(numb)             # 還是100, 說明建立的10個子程序都訪問不到主程序裡的numb, 空間隔離說法成立. 

驗證程序間的記憶體互相訪問不到

9、殭屍程序: 一個子程序退出, 那麼子程序的程序描述符仍然儲存在系統中。這種程序稱之為僵死程序

　  孤兒程序：一個父程序退出，而它的一個或多個子程序還在執行，那麼那些子程序將成為孤兒程序。孤兒程序將被init程序(程序號為1)所收養，並由init程序對它們完成狀態收集工作。

 　　(瞭解ok)