作業系統發展史程序

udp是傳輸層的協議，功能即為在ip的資料報服務之上增加了最基本的服務：復用和分用以及差錯檢測。

udp提供不可靠服務，具有tcp所沒有的優勢：

import socket
udp_sk = socket.socket(type=socket.sock_dgram)  # udp協議
udp_sk.bind(('127.0.0.1',9000))  # 繫結位址
msg,addr = udp_sk.recvfrom(1024)
udp_sk.sendto(b'hi',addr)             
udp_sk.close() 
import socket
ip_port=('127.0.0.1',9000)
udp_sk=socket.socket(type=socket.sock_dgram)
udp_sk.sendto(b'hello',ip_port)
back_msg,addr=udp_sk.recvfrom(1024)
print(back_msg.decode('utf-8'),addr)
"""時間伺服器的實現原理
1.內部小電容供電
2.遠端時間同步
"""例子：簡易qq程式

作業系統發展史就是圍繞著提高cpu利用率發展的，每次技術的進步，cpu的利用率就大大提高

"""學習併發程式設計其實就是在學習作業系統的發展史(底層邏輯)"""

cpu利用率極低

使用計算機的人要拿著自己的程式（穿孔卡片）在門外等候，輸入時間非常長，cpu利用時間就少

將多個程式設計師的程式一次性錄入磁帶中之後交由輸入機輸入並由cpu執行

現代計算機的雛形(遠端輸入高速磁帶主機)

工作人員只需要買一台輸入裝置在家，就可以把程式傳輸到高速磁帶中（記憶體），然後再用cpu執行

前提是單核cpu

切換：cpu在執行程序**時，如果遇到進行io操作會立刻停止當前程序的執行，切換到其它程序的執行中去

儲存狀態：在切換之前，會保留當前程序的執行狀態，以便切換回來時可以在斷開處繼續

''' cpu工作機制： 1、當某個程式進入io操作狀態時，作業系統會強行剝奪該程式的cpu執行許可權 2、當某個程式長時間占用cpu時，作業系統也會強行剝奪該程式的cpu執行許可權 '''並行與併發：並行：多個程式同時執行（每個程式執行都需要乙個cpu）併發：多個程式只要看起來像是同時執行的就可以 # 問:單核cpu能否實現並行肯定不能，但是可以實現併發 # 問:12306可以同一時間支援幾個億的使用者買票問是並行還是併發肯定是併發(高併發) 星軌:微博能夠支援八個星軌

程式：實現功能的程式設計**，存在硬碟中（是死的）

程序：執行中的應用程式，存在記憶體中（是活的）

對短作業不友好

對長作業不友好

1、先給所有要執行的程序分配相同的時間片（cpu執行時間）

2、然後根據每個程序消耗的時間片多少進行分級，需要執行時間長的進入下一級

3、優先執行第一級需要時間片少的程序

同步

cpu 提交任務之後原地等待返回資訊，再去執行其它任務

非同步

提交任務之後不會等待，先去執行其它任務，接收到返回資訊後再回來執行，有反饋機制

阻塞

阻塞態：io操作、異常斷開

非阻塞

就緒態與執行態

直接建立程序物件（主要的）

from multiprocessing import process
import time
import os
def run(name):
print(os.getpid()) # 獲取程序號
print(os.getppid()) # 獲取父程序號
print('%s is running ' % name)
time.sleep(3)
print('%s is over' % name)
if __name__ == '__main__':
p = process(target=run, arg=('elijah', ))  # 生成乙個程序物件
p.start()  # 告訴作業系統要啟動這個子程序，然後繼續執行主程序   非同步提交
print(os.getpid())
print('主程序')
'''在windows中開設程序類似於匯入模組
**自上而下執行
一定要在__main__判斷語句內執行開設程序的**
否則，被匯入模組也會執行開設程序的**，這樣會陷入死迴圈
''''''
在linux中是直接將**完整地複製乙份執行
不用在__main__判斷語句中執行
'''

用類建立程序物件

class myprocess(process):
def __init__(self, name):
super().__init__()
self.name = name
def run(self):
print('%s正在執行' % self.name)
time.sleep(3)
print('%s已經結束' % self.name)
if __name__ == '__main__':
p = myprocess('jason')
p.start()
print('主')

主程序開設子程序之後，等待子程序執行完成之後再往下執行

from multiprocessing import process
import time
def run(name, n):
print('%s is running' % name)
time.sleep(n)
print('%s is over' % name)
if __name__ == '__main__':
start_time = time.time()
process_list = 
for i in range(1, 4):
p = process(target=run, args=(i, i))
p.start()
for p in process_list:
p.join()
print(time.time() - start_time)
print('主程序')
# 執行結果
1 is running
2 is running
3 is running
1 is over
2 is over
3 is over
3.309438943862915	# 執行時間
主程序'''當第乙個 p.join() 執行時，只有主程序會在原地等待它執行結束
其它兩個子程序並不受影響，會繼續執行
所以總的時間是最長的那個子程序執行時間
'''

主程式開設子程式，相當於再開闢了一塊記憶體重新執行一遍**（以被匯入模組執行，__main__判斷語句內的**不會執行），那它執行修改資料操作不會影響到主程序的資料，因為程序之間預設無法進行互動

from multiprocessing import process
money = 100
def test():
global money
money = 90
if __name__ == '__main__':
p = process(target=test)
p.start()
p.join()
print(money)
# 執行結果
100

1.current_process檢視程序號 2.os.getpid() 檢視程序號 os.getppid() 檢視父程序程序號 3.程序的名字，p.name直接預設就有，也可以在例項化程序物件的時候通過關鍵字形式傳入name='' 3.p.terminate() 殺死子程序 4.p.is_alive() 判斷程序是否存活 3，4結合看不出結果，因為作業系統需要反應時間。主程序睡0.1即可看出效果

作業系統發展史 程序

作業系統發展史

作業系統發展史

作業系統發展史

相關推薦

作業系統發展史程序