實現原理:
統一時間,載入多個任務到記憶體中,多個程序之間記憶體區域需要相互隔離,這種隔離是物理層面的隔離,其目的是為了保證數安全
指的是,作業系統會在多個程序之間做切換執行
切換任務的兩種情況
1.當乙個程序遇到了io操作 時會自動切換
2.當乙個任務執行時間超過閾值會強制切換
注意:在切換前必須儲存狀態,以便後續恢復執行
並且 頻繁的切換其實也需要消耗資源
當所有任務都沒有io操作時,切換執行效率反而降低,但是為了保證併發執行 必須犧牲效率
簡單的總結就是切換加儲存
有了多道技術,計算機就可以同時併發的處理多個任務
自上而下執行
真正的同時執行,必須具備多核cpu ,有幾個核心就能並行幾個任務,當任務數量超過核心數還是併發執行
併發指的是多個任務同時被執行，併發程式設計指的是編寫支援多工併發的應用程式。
程序指的是正在執行的程式，是一系列過程的統稱，也是作業系統在排程和進行資源分配的基本單位
程序是實現併發的一種方式
乙個程式可以產生多個程序
pid:系統給程序的編號
ppid:當乙個程序a開啟了另乙個程序b，那麼a被稱為b的父程序。當pycharm執行了py檔案，那麼pycharm就是py檔案的父程序
併發指的是，多個事件同時發生了，需要一直切換完成
並行指的是，多個事件同時進行，互不影響
阻塞狀態是因為程式遇到了io操作，或是sleep，導致後續的**不能被cpu執行
非阻塞與之相反，表示程式正在被cpu執行。
程序有三種狀態，就緒態，執行態，阻塞態
python中開啟子程序的兩種方式
from multiprocessing import process
import time
def task(name):
print(f' is running ')
time.sleep(3)
print('f is fone')
if __name__=='__main__':
#在windows系統之上，開啟子程序的操作一定要放在這個裡面
#process(target=task,kwargs=)
p=process(target=task,args=('jack',))#引數放在元祖裡
p.start() # 向作業系統傳送請求，作業系統會申請記憶體空間，然後把父程序的資料拷貝給子程序，作為子程序的初始狀態
print('主')
from multiprocessing import process
import time
class myprocess(process):
def __init__(self,name):
super(myprocess,self).__init__()
self.name=name
def run(self):
print('%s is running' %self.name)
time.sleep(3)
print('%s is done' %self.name)
if __name__ == '__main__':
p=myprocess('jack')
p.start()
print('主')
3.start僅僅是給作業系統傳送訊息，而作業系統建立程序是要花費時間的，所以會有兩種情況傳送
3.1開啟程序速度慢於程式執行速度，先列印」主「 在列印task中的訊息
3.2開啟程序速度快於程式執行速度，先列印task中的訊息，在列印」主「
在乙個程序內修改了全域性變數，其他程序不受影響。就像是執行兩個檔案，乙個修改了，另外乙個不受影響。
from multiprocessing import process
import time
x=1000
def task():
global x
x=0print('兒子死啦',x)
if __name__ == '__main_
print(x)
p=process(target=task)
p.start()
time.sleep(5)
print(x)
###1000
兒子死啦 0
1000
from multiprocessing import process
import time
x=1000
def task():
time.sleep(3)
global x
x=0print('兒子死啦',x)
if __name__ == '__main__':
p=process(target=task)
p.start()
p.join() # 讓父親在原地等,如果不加join函式，則會先執行print（x）
print(x)
from multiprocessing import process
import time,random
x=1000
def task(n):
print('%s is runing' %n)
time.sleep(n)
if __name__ == '__main__':
start_time=time.time()
p1=process(target=task,args=(1,))
p2=process(target=task,args=(2,))
p3=process(target=task,args=(3,))
p1.start()
p2.start()
p3.start()
p3.join() #3s
p1.join()
p2.join()
print('主',(time.time() - start_time))
start_time=time.time()
p_l=
for i in range(1,4):
p=process(target=task,args=(i,))
p.start()
for p in p_l:
p.join()
print('主',(time.time() - start_time))
from multiprocessing import process
def task(n):
print('%s is runing' %n)
time.sleep(n)
if __name__ == '__main__':
start_time=time.time()
p1=process(target=task,args=(1,),name='任務1')
p1.start() # 啟動程序
print(p1.pid) # 獲取程序pid
print(p1.name) # 獲取程序名字
p1.terminate() # 終止程序
p1.join() # 提高優先順序
print(p1.is_alive()) # 獲取程序的存活狀態
print('主')
指的是開啟子程序後，父程序先於子程序終止了，那這個子程序就稱之為孤兒程序。
孤兒程序是無害的，有其存在的必要性，在父程序結束後，其子程序會被作業系統接管。
殭屍程序：
指的是當父程序先結束，而父程序又沒有**子程序，釋放子程序占用的資源，此時子程序會成為乙個殭屍程序，這種情況只在linux下出現。因為windows中程序完全是獨立的沒有任何關聯。
如果父程序先退出，子程序被作業系統接管，子程序退出後作業系統會**其占用的相關資源，
python已經幫我們自動處理了殭屍程序的**工作。
python併發程式設計 多程序
import os import time from multiprocessing import process def func args,args2 print args,args2 time.sleep 3 print 子程序 os.getpid print 子程序的父程序 os.getpp...
網路程式設計基礎 併發程式設計 多程序
python中的多執行緒無法利用多核優勢，如果想要充分地使用多核cpu的資源 os.cpu count 檢視 在python中大部分情況需要使用多程序。python提供了multiprocessing multiprocessing模組用來開啟子程序，並在子程序中執行我們定製的任務 比如函式 該模組...
併發程式設計多程序之佇列
程序彼此之間互相隔離，要實現程序間通訊 ipc multiprocessing模組支援兩種形式 佇列和管道，這兩種方式都是使用訊息傳遞的。建立佇列的類 底層就是以管道和鎖定的方式實現 queue maxsize 建立共享的程序佇列。queue是多程序安全的佇列，可以使用queue實現多程序之間的資料...