操做系統發展、同步異步阻塞非阻塞、進程

目錄

• 操做系統發展史
  • 穿孔卡片
  • 聯機批處理
  • 脫機批處理系統
  • 多道技術（基於單核狀況下研究）
  • 併發與並行
• 進程
  • 程序與進程：
  • 進程調度：
• 同步異步阻塞非阻塞
  • 進程的三個狀態：
  • 同步與異步
  • 阻塞與非阻塞
• 建立進程
  • 進程的建立
  • 建立子進程兩種方式
• join方法的使用
• 進程間數據是相互隔離的
• 進程對象的屬性
• 殭屍進程和孤兒進程（瞭解）
  • 殭屍進程
  • 孤兒進程
• 守護進程

操做系統發展史

穿孔卡片

一個計算機房，只能被一個穿孔卡片使用

缺點：

• CPU利用率低

聯機批處理

支持多用戶去使用一個計算機房

脫機批處理系統

高速磁盤：

• 提升文件的讀取速度

優勢：

• 提升CPU的利用率

多道技術（基於單核狀況下研究）

• 單道：多個使用CPU是串行
• 多道：
  • 空間上的複用：一個CPU能夠提供給多個用戶去使用
  • 時間上的複用：切換 + 保存狀態

時間上覆用說明：

（1）若CPU遇到IO操做，會當即將當前執行程序CPU使用權斷開
優勢：CPU的利用率高

（2）若一個程序使用CPU的時間過長，會當即將當前執行程序CPU使用權斷開

缺點：程序的執行率下降

併發與並行

併發：指的是看起來像同時運行，多個程序不停地切換 + 保存狀態

並行：真實意義上的同時運行

進程

程序與進程：

• 程序：一堆代碼
• 進程：一堆代碼運行的過程

進程調度：

當代操做系統使用的是：時間片輪轉法 + 分級反饋隊列

1. 先來先服務調度：

   a, b程序， 若a程序先來， 先佔用CPU

   缺點：程序a先使用，程序b必須等待程序a使用CPU結束後才能使用

2. 短做業優先調度：

   a, b程序，誰的用時短，先優先調度使用cpu

   缺點：若程序a使用時間最長，有N個程序使用時間短，必須等待全部用時短的程序結束後才能使用

3. 時間片輪轉法

   CPU執行的時間1秒中，加載N個程序。要將1秒鐘等分N個時間片

4. 分級反饋隊列
   將執行優先分爲多層級別

同步異步阻塞非阻塞

進程的三個狀態：

• 就緒態：全部程序建立時都會進入就緒態，準備調度
• 運行態：調度後的進程，進入運行態
• 阻塞態：凡是遇到IO操做的進程，都會進入阻塞態；若IO結束必須從新進入就緒態

同步與異步

指的是提交任務的方式

• 同步：如有兩個任務須要提交，在提交第一個任務時，必須等待該任務執行結束後，才能繼續提交併執行第二個任務。

• 異步：如有兩個任務須要提交，在提交第一個任務時，不須要原地等待，當即能夠提交併執行第二個任務。

阻塞與非阻塞

• 阻塞：遇到IO必定會阻塞
• 非阻塞：指的是就緒態、運行態

最大化提升CPU的使用率：

儘量減小沒必要要的IO操做

建立進程

進程的建立

windows中建立子進程，會將當前父進程代碼從新加載執行一次

在Linux/mac中，會將當前父進程從新拷貝一份，再去執行

建立子進程兩種方式

from multiprocessing import Process
import time

# 定義一個任務
def task(name):
    print(f'{name}的任務開始執行')
    time.sleep(1)
    print(f'{name}的任務已經結束')


if __name__ == '__main__':
    p = Process(target=task, args=('cwz',))
    p.start()
    print('主進程')
    
'''
主進程
cwz的任務開始執行
cwz的任務已經結束
'''

# 自定義一個類，並繼承Process
class MyProcess(Process):

    # 父類方法
    def run(self):
        print('開始執行任務')
        time.sleep(1)
        print('結束執行任務')

if __name__ == '__main__':
    p = MyProcess()
    p.start()
    print('主進程')

'''
主進程
開始執行任務
結束執行任務
'''

join方法的使用

用來告訴操做系統，讓子進程結束後再結束父進程

from multiprocessing import Process
import time

def task(name):
    print(f'{name} start...')
    time.sleep(2)
    print(f'{name} over...')


if __name__ == '__main__':
    p = Process(target=task, args=('neo', ))
    p.start()   # 告訴操做系統，開啓子進程
    p.join()    # 告訴操做系統，結束子進程後，父進程再結束
    print('主進程')
    
    
'''
neo start...
neo over...
主進程
'''

進程間數據是相互隔離的

from multiprocessing import Process
import time

x = 100
def func():
    print('執行func函數')
    global x
    x = 200


if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(x)   # 不能修改x的值
    print('主進程')
    
    
'''
100
主進程
執行func函數
'''

進程間數據相互隔離：
主進程與子進程間會有各自的名稱空間

進程對象的屬性

• p.daemon：默認值爲False，若是設爲True，表明p爲後臺運行的守護進程，當p的父進程終止時，p也隨之終止，而且設定爲True後，p不能建立本身的新進程，必須在p.start()以前設置
• p.name：進程的名稱
• p.pid：進程的pid
• p.exitcode：進程在運行時爲None、若是爲–N，表示被信號N結束(瞭解便可)
• p.authkey：進程的身份驗證鍵,默認是由os.urandom()隨機生成的32字符的字符串。這個鍵的用途是爲涉及網絡鏈接的底層

from multiprocessing import Process
from multiprocessing import current_process
import time
import os

def task(name):
    # current_process().pid 獲取子進程號
    print(f'{name} start...', current_process().pid)
    time.sleep(2)
    print(f'{name} over...', current_process().pid)


if __name__ == '__main__':
    p = Process(target=task, args=('neo', ))
    p.start()
    print('主進程', os.getpid())
    print('主主進程', os.getppid())


'''
主進程 12576
主主進程 12476
neo start... 7772
neo over... 7772
'''

進程號回收的兩種條件：

• join， 能夠回收子進程與主進程
• 主進程正常結束，子進程與主進程也會回收

主進程這裏指的是python解釋器

主主進程指的是pycharm

p.is_alive 能夠查看子進程存活狀態

from multiprocessing import Process
from multiprocessing import current_process
import time
import os

def task(name):
    # current_process().pid 獲取子進程號
    print(f'{name} start...', current_process().pid)
    time.sleep(2)
    print(f'{name} over...', current_process().pid)


if __name__ == '__main__':
    p = Process(target=task, args=('neo', ))
    p.start()
    # p.join()

    print(p.is_alive())
    p.terminate()  # 直接告訴操做系統，終止子進程
    time.sleep(1)
    print(p.is_alive()) # 判斷子進程是否存活
    print('主進程', os.getpid())
    print('主主進程', os.getppid())
    
    
'''
True
False
主進程 10708
主主進程 12476
'''

殭屍進程和孤兒進程（瞭解）

殭屍進程

指的是子進程已經結束，但PID號還存在，未銷燬

殭屍進程會佔用PID號，佔用操做系統資源

孤兒進程

指的是子進程還在執行，但父進程意外結束。

操做系統內部優化機制：會自動回收沒有父的子進程

守護進程

指的是主進程結束後，該主進程產生的全部子進程跟着結束，並回收

from multiprocessing import Process
from multiprocessing import current_process
import time

def task(name):
    print(f'{name} start...', current_process().pid)
    time.sleep(3)
    print(f'{name} over...', current_process().pid)
    print('子進程')

if __name__ == '__main__':
    p = Process(target=task, args=('cwz', ))
    p.daemon = True   # True表示該進程是守護進程
    p.start()
    print('主進程')
    
    
'''
主進程
'''