pt14多任务编程
多任務編程
cpu輪詢機制 ： cpu都在多個任務之間快速的切換執行，切換速度在微秒級別，其實cpu同時只執行一個任務，但是因為切換太快了，從應用層看好像所有任務同時在執行。
并發 ： 多個任務如果被分配給了一個cpu內核，那么這多個任務之間就是并發關系，并發關系的多個任務之間并不是真正的"同時"。
并行 ： 多個任務如果被分配給了不同的cpu內核，那么這多個任務之間執行時就是并行關系，并行關系的多個任務時真正的“同時”執行。
多任務編程：一個程序中編寫多個任務，在程序運行時讓這多個任務一起運行，而不是一個一個的順次執行。比如微信視頻聊天，這時候在微信運行過程中涉及視頻、音頻、發消息。
實現多任務編程的方法 ： 多進程編程，多線程編程
多任務意義
-
提高了任務之間的配合，可以根據運行情況進行任務創建。
-
充分利用計算機資源，提高了任務的執行效率。
-
在任務中無阻塞時只有并行狀態才能提高效率
-
在任務中有阻塞時并行并發都能提高效率
-
進程（Process）
進程概述：程序在計算機中的一次執行過程。
-
程序是一個可執行的文件，是靜態的占有磁盤。
-
進程是一個動態的過程描述，占有計算機運行資源，有一定的生命周期。
-
進程狀態
三態 就緒態 ： 進程具備執行條件，等待系統調度分配cpu資源 運行態 ： 進程占有cpu正在運行 等待態 ： 進程阻塞等待，此時會讓出cpu五態 (在三態基礎上增加新建和終止)新建 ： 創建一個進程，獲取資源的過程終止 ： 進程結束，釋放資源的過程進程命令
查看進程信息
ps -aux * USER ： 進程的創建者 * PID : 操作系統分配給進程的編號,大于0的整數，系統中每個進程的PID都不重復。PID也是重要的區分進程的標志。 * %CPU,%MEM : 占有的CPU和內存 * STAT ： 進程狀態信息，S I 表示阻塞狀態 ，R 表示就緒狀態或者運行狀態 * START : 進程啟動時間 * COMMAND : 通過什么程序啟動的進程 pstree進程樹形結構- 父子進程：在Linux操作系統中，進程形成樹形關系，任務上一級進程是下一級的父進程，下一級進程是上一級的子進程。
多進程編程 multiprocessing
創建流程
1、將需要新進程執行的事件封裝為函數 2、通過模塊的Process類創建進程對象，關聯函數 3、通過進程對象調用start啟動進程主要類和函數使用
Process()功能 ： 創建進程對象參數 ： target 綁定要執行的目標函數 args 元組，用于給target函數位置傳參kwargs 字典，給target函數鍵值傳參daemon bool值，讓子進程隨父進程退出p.start() 功能 ： 啟動進程注意: 啟動進程此時target綁定函數開始執行，該函數作為新進程執行內容，此時進程真正被創建p.join([timeout])功能：阻塞等待子進程退出參數：最長等待時間進程執行現象理解 （難點）
新的進程是原有進程的子進程，子進程復制父進程全部內存空間代碼段，一個進程可以創建多個子進程。 子進程只執行指定的函數，其余內容均是父進程執行內容，但是子進程也擁有其他父進程資源。 各個進程在執行上互不影響，也沒有先后順序關系。 進程創建后，各個進程空間獨立，相互沒有影響。 multiprocessing 創建的子進程中無法使用標準輸入（即無法使用input）。 """ 進程創建示例 01 """ import multiprocessing as mp from time import sleepa = 1 # 全局變量# 進程目標函數 def fun():print("開始運行一個進程")sleep(2) # 模擬事件執行事件global aprint("a =",a) # Yesa = 10000print("進程執行結束")# 實例化進程對象 windos系統需要放在main函數下 process = mp.Process(target=fun)# 啟動新進程 進程產生 執行fun 與下面的第一個print搶占執行沒關系 process.start() #如果使用函數fun()，執行時間5秒print("我也做點事情") sleep(3) print("我也把事情做完了...")process.join() # 阻塞等待子進程結束,子進程不影響父進程 print("a:",a) # 1############## windos系統需要將多進程放在main函數下 if __name__ == '__main__':process = mp.Process(target=func)process.start() # 啟動進程 --》 執行funcprint("哎呦，我也干點事吧")sleep(5)print("哈哈，我也干完了")含有參數的進程函數練習
""" 進程創建示例02 ： 含有參數的進程函數 """ from multiprocessing import Process from time import sleep# 含有參數的進程函數 def worker(sec,name):for i in range(3):sleep(sec)print("I'm %s"%name)print("I'm working....")# 元組位置傳參 # p = Process(target=worker,args=(2,"Tom"))# 關鍵字傳參，或者同時使用 p = Process(target=worker,args = (2,),kwargs={"name":"Tom"},daemon=True) # 子進程伴隨父進程結束 p.start() sleep(3)進程處理細節
進程相關函數
os.getpid()功能： 獲取一個進程的PID值返回值： 返回當前進程的PID os.getppid()功能： 獲取父進程的PID號返回值： 返回父進程PID sys.exit(info)功能：退出進程參數：字符串 表示退出時打印內容 """ 創建多個子進程 """ from multiprocessing import Process from time import sleep import sys, os ## sys.exit("不能睡覺了") 結束進程并提示def th1():sleep(3)print("吃飯")print(os.getppid(), "--", os.getpid())def th2():# sys.exit("不能睡覺了") # 進程結束sleep(1)print("睡覺")print(os.getppid(), "--", os.getpid())def th3():sleep(2)print("打豆豆")print(os.getppid(), "--", os.getpid())# 循環創建子進程 jobs = [] # 存放每個進程對象def make_th():for th in [th1, th2, th3]:p = Process(target=th)jobs.append(p) # 存入jobsp.start() # 循環創建子進程 jobs = [] # 存放每個進程對象if __name__ == '__main__':# window是系統不能直接使用，需要放到main函數里使用或調用make_th()# 確保三件事都結束for i in jobs:i.join()print("三件事完成")大文件拆分
""" 有一個大文件，將其拆分成上下兩個部分 （按照字節大小）， 要求兩個部分拆分要同步進行,不用合并 plus ： 假設文件很大不要一次read讀取全部 os.path.getsize() """ import os from multiprocessing import Process# 復制上半部分 def top(filename):fr = open(filename, 'rb')fw = open("top.jpeg", 'wb')n = os.path.getsize(filename) // 2while n >= 1024:fw.write(fr.read(1024))n -= 1024fw.write(fr.read(n))fr.close()fw.close()# 復制下半部分 def bot(filename):fr = open(filename, 'rb')fw = open("bot.jpeg", 'wb')n = os.path.getsize(filename) // 2fr.seek(n) # 文件偏移量到中間while True:data = fr.read(1024)if not data:breakfw.write(data)fr.close()fw.close()def main():jobs = []for func in [top, bot]:p = Process(target=func, args=("/home/下載/bizhi.jpeg",))jobs.append(p)p.start()[i.join() for i in jobs] # 和循環一個意思 酷print("文件拆分完成")if __name__ == '__main__':main()孤兒進程和僵尸進程
-
孤兒進程： 父進程先于子進程退出時，子進程會成為孤兒進程，孤兒進程會被系統自動收養，成為孤兒進程新的父進程，并在孤兒進程退出時釋放其資源。
-
僵尸進程： 子進程先于父進程退出，父進程又沒有處理子進程的退出狀態，此時子進程就會成為僵尸進程。
特點： 僵尸進程雖然結束，但是會存留部分進程資源在內存中，大量的僵尸進程會浪費系統資源。Python模塊當中自動建立了僵尸處理機制，每次創建新進程都進行檢查，將之前產生的僵尸處理掉，而且父進程退出前，僵尸也會被自動處理。
""" 僵尸進程 """ from multiprocessing import Process import os from time import sleepdef fun():print("子進程結束變為僵尸：", os.getpid())#while True: #使用這段循環，產生僵尸進程 # passwhile True:passsleep(3)p = Process(target=fun)p.start() # 創建進程前會自動檢測處理已有僵尸# p.join() # 處理僵尸
創建進程類
進程的基本創建方法將子進程執行的內容封裝為函數。如果我們更熱衷于面向對象的編程思想，也可以使用類來封裝進程內容。
創建步驟繼承Process類重寫`__init__`方法添加自己的屬性，使用super()加載父類屬性重寫run()方法使用方法實例化對象調用start自動執行run方法自定義進程類練習
""" 自定義進程類 --》 面向對象思想 """ from multiprocessing import Process from time import sleepclass MyProcess(Process):def __init__(self, value):self.value = valuesuper().__init__() # 加載調用父類方法# 父類提供的方法接口--》 我們重寫即可使用def run(self):self.func()def func(self):for i in range(self.value):sleep(2)print("自己進程的事情")if __name__ == '__main__':p = MyProcess(3)p.start() # 創建進程 -->執行run方法作為進程內容判斷質數、求和、計時
#判斷一個數是否為質數 質數: 只能被1和其本身整除的整數且>1 def is_prime(num):if num <= 1:return Falsefor i in range(2,num // 2 + 1): #判斷到num的一半即可，eg：100 不能被50+1以上的數整除if num % i == 0:return Falsereturn Truedef sum_prime():prime = [] # 存放所有質數for i in range(1,100001):if is_prime(i):prime.append(i)print(sum(prime)) # 求和begin = time.time() sum_prime() # 用時： 12.56395149230957 print("用時：",time.time() - begin)練習
""" 1. 求100000以內質數之和，并且計算這個求和過程的時間 2. 將100000分成4份，創建4個進程，每個進程求其中一份的 質數之和，統計4個進程執行完的時間在無阻塞的任務執行中，并不是創建的進程越多越好，而是受到cpu硬件的制約 """ import time from multiprocessing import Process# 求begin -- end 之間的質數之和 class Prime(Process):@staticmethoddef is_prime(n):if n <= 1:return Falsefor i in range(2, n // 2 + 1):if n % i == 0:return Falsereturn Truedef __init__(self,begin,end):self.begin = begin # 起始數字self.end = end # 結尾數字super().__init__()def run(self):prime = [] # 存放所有質數for i in range(self.begin,self.end):if Prime.is_prime(i):prime.append(i) # 存入列表print(sum(prime))if __name__ == '__main__':jobs = []b = time.time()for i in range(1,100001,10000): #利用步長分割,10進程 p = Prime(i,i + 10000)#for i in range(1,100001,25000): #利用步長分割 4進程 # p = Prime(i,i + 25000) jobs.append(p)p.start()[i.join() for i in jobs]print("用時:",time.time()-b)進程間通信
進程間空間獨立，資源不共享，此時在需要進程間數據傳輸時就需要特定的手段進行數據通信。
常用進程間通信方法：消息隊列，套接字等。
消息隊列使用： 在內存中開辟空間，建立隊列模型，進程通過隊列將消息存入，或者從隊列取出完成進程間通信。
實現方法
from multiprocessing import Queueq = Queue(maxsize=0)功能: 創建隊列對象參數：最多存放消息個數，列表、字典、字符串...返回值：隊列對象q.put(data)功能：向隊列存入消息,滿了阻塞參數：data 要存入的內容q.get()功能：從隊列取出消息，空了阻塞，先進先出返回值： 返回獲取到的內容q.full() 判斷隊列是否為滿 q.empty() 判斷隊列是否為空 q.qsize() 獲取隊列中消息個數 q.close() 關閉隊列 進程間通信示例： from multiprocessing import Process,Queue# 創建消息隊列 q = Queue(5)# 子進程函數 def handle():while True:cmd = q.get() # 取出指令if cmd == "1":print("\n完成指令1")elif cmd == "2":print("\n完成指令2")# 創建進程 p = Process(target=handle,daemon=True) p.start()while True:cmd = input("指令：")if not cmd:breakq.put(cmd) # 通過隊列給子進程練習
""" 有一個目錄中有若干普通文件，將該目錄復制一份到當前程序所在位置 要求： 目標文件夾中每個文件復制都采用一個獨立的進程完成當所有文件復制完成之后，按復制完成順序打印所有文件名 思路提示：子進程負責拷貝文件父進程做文件是否重名判斷，接收用戶輸入指令創建文件夾 ： os.mkdir(dir) os.listdir() """from multiprocessing import Process, Queue import osold = "/home/FTP/" new = "./FTP/" q = Queue() # 消息隊列，用于傳遞文件名def copy():while True:filename = q.get() # 從消息隊列獲取名字if filename == '##':break # 文件已經拷貝完成fr = open(old + filename, 'rb')fw = open(new + filename, 'wb')while True:data = fr.read(1024)if not data:breakfw.write(data)fr.close()fw.close()def select_file():new_files = os.listdir(new) # 當前目錄FTP下的文件for file in os.listdir(old):if file in new_files:print("已存在%s 1.替換 2.跳過" % file)cmd = input("請選擇:")if cmd == "1":q.put(file) # 選擇1 則也放入消息隊列else:q.put(file) # 要拷貝的文件名放入消息隊列q.put("##") # 子進程結束標志def main():p = Process(target=copy)p.start()select_file() # 文件篩選if __name__ == '__main__':main()群聊聊天室框架搭建設計步驟
功能 ： 類似qq群功能 有人進入聊天室需要輸入姓名，姓名不能重復 有人進入聊天室時，其他人會收到通知：Lucy 進入了聊天室 一個人發消息，其他人會收到： Lucy ： 一起出去玩啊。 有人退出聊天室，則其他人也會收到通知 : Lucy 退出了聊天室 擴展功能：服務器可以向所有用戶發送公告: 管理員消息： 大家好，歡迎進入聊天室。 需求認知 ： C / S使用流程 ：開始——進入--聊天--退出--結束模塊劃分 ： 進入聊天室 聊天 退出函數技術點設計： 網絡 UDP（暫用，練習）存儲：姓名 地址 [(name,address)] {name:address}發送接收 ： 轉發收發互不影響-》分進程完成通信協議設計 （請求不止一種）請求類型 數據參數進入聊天室 LOGIN name聊天 CHAT content退出 EXIT name具體每個模塊邏輯設計--》編碼搭建框架 ： udp網絡循環模型進入聊天室客戶端 輸入名字發送給服務端接收結果--》 是否進程是 ： 功能結束否 ： 重新回到第一步服務端 接收名字判斷是否可以進入聊天室 （名字是否重復）發送結果是 ： 給其他人發通知，存儲用戶信息否 ： 功能結束聊天退出網絡通信搭建
""" 慣例信息 姓名 ： name 郵箱 ：123456@qq.cn 時間 ： 2000-01-11 環境 ： Python3.6在線的群聊聊天室，鞏固網絡udp和進程知識 """ from socket import *# 服務地址 HOST = "0.0.0.0" PORT = 8888 ADDR = (HOST, PORT)# 建立存儲容器 {name:address} user = {}# 處理用戶進入 def do_login():passdef do_chat():passdef do_exit():pass# 入口函數，搭建網絡模型 def main():sock = socket(AF_INET, SOCK_DGRAM) # UDPsock.bind(ADDR)# 總體循環接收請求，分情況討論 總分while True:request, addr = sock.recvfrom(1024)print(request) #創建通信測試，OK后去掉if __name__ == '__main__':main() """ chat 客戶端 """ from socket import * from multiprocessing import Process# 服務器地址 ADDR = ("127.0.0.1", 8888)def do_login(sock):passdef do_chat():passdef do_exit():pass# 入口函數 def main():sock = socket(AF_INET, SOCK_DGRAM) # UDPsock.sendto(b'test',ADDR) #創建通信測試，OK后去掉# 順次向下按照步驟執行do_login(sock)do_chat()do_exit()if __name__ == '__main__':main()# ### 框架通信測試：先動服務端，再啟動客服端，看通信是否正常 服務端收到b'test'login功能添加
"""server端""" from socket import *# 服務地址 HOST = "0.0.0.0" PORT = 8888 ADDR = (HOST, PORT)# 建立存儲容器 {name:address} user = {}# 處理用戶進入 def do_login(sock, name, addr):if name in user:sock.sendto(b"FAIL", addr)else:sock.sendto(b"OK", addr)msg = "歡迎 %s 進入聊天室" % namefor key, value in user.items():sock.sendto(msg.encode(), value)user[name] = addr # 增加用戶def do_chat():passdef do_exit():pass# 入口函數，搭建網絡模型 def main():sock = socket(AF_INET, SOCK_DGRAM) # UDPsock.bind(ADDR)# 總體接收請求，分情況討論 總分while True:request, addr = sock.recvfrom(1024)tmp = request.decode().split(' ') # 簡單的解析 tmp->[LOGIN,name]if tmp[0] == "LOGIN":do_login(sock, tmp[1], addr)elif tmp[0] == "CHAT":do_chat()elif tmp[0] == "EXIT":do_exit()if __name__ == '__main__':main() """ 客戶端 """ from socket import * from multiprocessing import Process# 服務器地址 ADDR = ("127.0.0.1",8888)def do_login(sock):while True:name = input("請輸入昵稱:")msg = "LOGIN " + name # 請求sock.sendto(msg.encode(),ADDR)result,addr = sock.recvfrom(1024)if result == b'OK':print("進入聊天室成功")breakelse:print("該昵稱已存在")def do_chat():passdef do_exit():pass# 入口函數 def main():sock = socket(AF_INET,SOCK_DGRAM) # UDPsock.sendto(b'test', ADDR)# 順次向下按照步驟執行do_login(sock)do_chat()do_exit()if __name__ == '__main__':main()其他功能代碼
聊天 客戶端 創建一個子進程父進程負責循環發送子進程負責循環接收服務端 接收客戶端請求 簡單解析將內容轉發給其他人退出 客戶端： 發送請求，結束服務端： 通知其他人 刪除用戶信息優化完善 ################ 服務端參考代碼 ################### """ 慣例信息 姓名 ： name 郵箱 ：123456@qq.cn 時間 ： 2000-01-11 環境 ： Python3.6在線的群聊聊天室，鞏固網絡udp和進程知識 """ from socket import * from multiprocessing import Process# 服務器地址 HOST = "0.0.0.0" PORT = 8888 ADDR = (HOST, PORT)# 存儲用戶信息 {name:address} user = {}# 處理進入聊天室 def login(sock, name, address):if name in user or "管理" in name: #名字里不能帶管理sock.sendto(b"FAIL", address)else:sock.sendto(b"OK", address)# 告知其他人msg = "歡迎 %s 進入聊天室" % namefor key, value in user.items():sock.sendto(msg.encode(), value)user[name] = address # 存儲用戶# print(user) # 測試# 處理聊天 def chat(sock, name, content):msg = "%s : %s" % (name, content)for key, value in user.items():# 不是本人就發送if key != name:sock.sendto(msg.encode(), value)# 處理退出 def exit(sock, name):if name in user:del user[name] # 刪除該用戶# 通知其他用戶msg = "%s 退出聊天室" % namefor key, value in user.items():sock.sendto(msg.encode(), value)def handle(sock):# 不斷接收請求，分情況討論while True:request, addr = sock.recvfrom(1024)tmp = request.decode().split(" ", 2)# 分情況討論if tmp[0] == "LOGIN":# tmp ->[LOGIN,name]login(sock, tmp[1], addr)elif tmp[0] == "CHAT":# tmp ->[CHAT,name,content]chat(sock, tmp[1], tmp[2])elif tmp[0] == "EXIT":# tmp ->[EXIT,name]exit(sock, tmp[1])# 程序入口函數 def main():# 創建udpsock = socket(AF_INET, SOCK_DGRAM)sock.bind(ADDR)# 接收請求，分類處理p = Process(target=handle, args=(sock,), daemon=True)p.start()while True:content = input("管理員消息:")if not content:breakmsg = "CHAT 管理員消息 " + content # 從父進程發送到子進程，不能遍歷user{}發送，父子進程隔離sock.sendto(msg.encode(), ADDR)if __name__ == '__main__':main()################## 客戶端參考代碼 ################## from socket import * from multiprocessing import Process import sys# 服務器地址 SERVER_ADDR = ("124.71.188.218", 8888)def login(sock):while True:name = input("請輸入昵稱:")# 組織請求msg = "LOGIN " + namesock.sendto(msg.encode(), SERVER_ADDR)result, addr = sock.recvfrom(1024)if result == b"OK":print("進入聊天室")return name """ 客戶端返回自己的name，給父進程使用發送msg """else:print("該昵稱已存在")# 子進程接收函數 def recv_msg(sock):while True:data, addr = sock.recvfrom(1024 * 10)# 格式處理content = "\n" + data.decode() + "\n發言："print(content, end="")# 父進程發送函數 def send_msg(sock, name):while True:try:content = input("發言：")except KeyboardInterrupt:content = "exit"# 表示退出if content == 'exit':msg = "EXIT " + namesock.sendto(msg.encode(), SERVER_ADDR)sys.exit("您已退出聊天室")msg = "CHAT %s %s" % (name, content) sock.sendto(msg.encode(), SERVER_ADDR)def main():sock = socket(AF_INET, SOCK_DGRAM)sock.bind(("0.0.0.0",55224)) # 端口不要變，udp端口會釋放改變name = login(sock) # 請求進入聊天室 接收返回的name給父進程使用# 子進程負責接收p = Process(target=recv_msg, args=(sock,), daemon=True)p.start()send_msg(sock, name) # 父進程發送消息 """客戶端返回自己的name，給父進程使用發送msg """if __name__ == '__main__':main()線程 (Thread)
線程概述
什么是線程線程被稱為輕量級的進程，也是多任務編程方式也可以利用計算機的多cpu資源線程可以理解為進程中再開辟的分支任務線程特征一個進程中可以包含多個線程線程也是一個運行行為，消耗計算機資源一個進程中的所有線程共享這個進程的資源多個線程之間的運行同樣互不影響各自運行線程的創建和銷毀消耗資源遠小于進程多線程編程 threading
#創建線程對象 from threading import Thread t = Thread() 功能：創建線程對象 參數：target 綁定線程函數args 元組 給線程函數位置傳參kwargs 字典 給線程函數鍵值傳參daemon bool值，主線程推出時該分支線程也推出 #啟動線程t.start()#等待分支線程結束t.join([timeout]) 功能：阻塞等待分支線程退出 參數：最長等待時間 """線程示例""" import threading from time import sleep import osa = 1# 線程函數 def music():global aprint("a =",a)a = 10000for i in range(3):sleep(2)print(os.getpid(),"播放:黃河大合唱")# 實例化線程對象 thread = threading.Thread(target=music)# 啟動線程 線程存在 thread.start() #分支線程6576 播放: 勇氣\n6576 播放: 勇氣\n6576 播放: 勇氣\na = 1for i in range(4):sleep(1)print(os.getpid(),"播放:葫蘆娃") #主線程：6576 播放: 葫蘆娃# 阻塞等待分支線程結束 thread.join() print("a:",a) #a=10000 """ 創建多個線程，線程參數 """ from threading import Thread from time import sleep# 含有參數的線程函數 def func(sec,name):print("含有參數的線程來嘍。")sleep(sec)print("%s線程執行結束"%name)# 循環創建線程 for i in range(5):t = Thread(target=func,args=(2,),kwargs={"name":"T-%d"%i})# daemon = True) # 分支線程隨主線程退出，加上的話可能打印不出結束t.start() #5個線程互不影響，搶占執行，結束順序不定 # daemon = True 分支線程隨主線程退出，加上的話，分支線程無法完成2秒等待的打印創建線程類
創建步驟繼承Thread類重寫`__init__`方法添加自己的屬性，使用super()加載父類屬性重寫run()方法使用方法
實例化對象；調用start自動執行run方法
from threading import Thread from time import sleepclass MyThread(Thread):def __init__(self,song):self.song = songsuper().__init__() # 得到父類內容# 線程要做的事情def run(self):for i in range(3):sleep(2)print("播放:",self.song)t = MyThread("涼涼") t.start() # 運行run 隨堂練習： 現在有500張票，存在一個列表中 ["T1",...."T500"]，10個窗口同時賣這500張票 W1-W10使用10個線程模擬這10個窗口，同時賣票，直到所有的票都賣出為止，每出一張票 需要0.1秒，打印表示即可print("W1----T250")from threading import Thread,Lock from time import sleeplock = Lock() # 創建鎖# 將票準備好 ticket = ["T%d" % x for x in range(1, 501)]# 線程函數 w:表示窗口 def sell(w):while ticket:print("%s --- %s"%(w,ticket.pop(0)))sleep(0.1)# 10個線程 for i in range(1,11):t = Thread(target=sell,args=("W%d"%i,))t.start()線程同步互斥
進程資源相互隔離，線程資源共享
線程通信方法： 線程間使用全局變量進行通信
共享資源爭奪
- 共享資源：多線程都可以操作的資源稱為共享資源。對共享資源的操作代碼段稱為臨界區。
- 影響 ： 對共享資源的無序操作可能會帶來數據的混亂，或者操作錯誤。此時往往需要同步互斥機制協調操作順序。
同步、互斥機制
-
同步 ： 同步是一種協作關系，為完成操作，線程間形成一種協調，按照必要的步驟有序執行操作。
-
互斥 ： 互斥是一種制約關系，當一個進程或者線程占有資源時會進行加鎖處理，此時其他進程線程就無法操作該資源，直到解鎖后才能操作。
線程Event
from threading import Evente = Event() #創建線程event對象 初始設置狀態unset：阻塞，set非阻塞e.wait([timeout]) #阻塞等待e被set 終端界面返回False阻塞，True非阻塞e.set() #設置e，使wait結束阻塞，返回Truee.clear() #使e回到未被設置狀態e.is_set() #查看當前e是否被設置Event使用示例
""" 線程同步互斥，注釋掉阻塞，if可能提前做，導致else結果 """ from threading import Thread,Evente = Event() # ---------------創建event對象 msg = None # 線程間通信def 楊子榮():print("楊子榮前來拜山頭")global msgmsg = "天王蓋地虎"e.set() # -------------------------解除初始狀態或者下面e.wait()阻塞t = Thread(target=楊子榮) t.start()print("說對口令才是自己人") e.wait() # ------------------阻塞等待 if msg == "天王蓋地虎":print("寶塔鎮河妖")print("確認過眼神，你是對的人") else:print("打死他...無情啊哥哥...")線程鎖 Lock
from threading import Locklock = Lock() 創建鎖對象 lock.acquire() 上鎖 返回True 如果lock已經上鎖再調用會阻塞 lock.release() 解鎖Lock使用示例
from threading import Thread, Locklock = Lock() # 創建鎖 a = b = 0def value():while True:lock.acquire() # ---------------上鎖 #注釋掉所有的鎖，將產生打印if a != b:print("a = %d,b = %d" % (a, b))lock.release() # ---------------解鎖t = Thread(target=value) t.start()while True:lock.acquire() # ---------------上鎖a += 1b += 1lock.release() # ---------------解鎖 隨堂練習： 使用兩個分支線程，一個線程打印1-52 這52個數字，另一個線程打印A-Z 這26個字母。要求同時執行兩個線程，打印順序為： 12A34B....5152Zfrom threading import Thread,Locklock1 = Lock() lock2 = Lock()def print_num():for i in range(1,53,2):lock1.acquire()print(i)print(i + 1)lock2.release()def print_chr():for i in range(65,91):lock2.acquire()print(chr(i))lock1.release()t1 = Thread(target=print_num) t2 = Thread(target=print_chr)lock2.acquire() # 先把打印字母的部分鎖住t1.start() t2.start()死鎖
什么是死鎖
死鎖是指兩個或兩個以上的線程在執行過程中，由于競爭資源或者由于彼此通信而造成的一種阻塞的現象，若無外力作用，它們都將無法推進下去。此時稱系統處于死鎖狀態或系統產生了死鎖。
死鎖產生條件
-
互斥條件：指線程使用了互斥方法，使用一個資源時其他線程無法使用。
-
請求和保持條件：指線程已經保持至少一個資源，但又提出了新的資源請求，在獲取到新的資源前不會釋放自己保持的資源。
-
不剝奪條件：不會受到線程外部的干擾，如系統強制終止線程等。
-
環路等待條件：指在發生死鎖時，必然存在一個線程——資源的環形鏈，如 T0正在等待一個T1占用的資源；T1正在等待T2占用的資源，……，Tn正在等待已被T0占用的資源。
-
如何避免死鎖
- 邏輯清晰，不要同時出現上述死鎖產生的四個條件
- 通過測試工程師進行死鎖檢測
GIL問題
什么是GIL問題 （全局解釋器鎖）
由于python解釋器設計中加入了解釋器鎖，導致python解釋器同一時刻只能解釋執行一個線程，大大降低了線程的執行效率。
導致后果
因為遇到阻塞時線程會主動讓出解釋器，去解釋其他線程。所以python多線程在執行多阻塞任務時可以提升程序效率，其他情況并不能對效率有所提升。
線程效率對比進程實驗
import time from threading import Threadclass Prime(Thread):@staticmethoddef is_prime(num):if num <= 1:return Falsefor i in range(2, num // 2 + 1):if num % i == 0:return Falsereturn Truedef __init__(self,begin,end):self.begin = beginself.end = endsuper().__init__()def run(self):prime = [] # 存放所有質數for i in range(self.begin,self.end):if Prime.is_prime(i):prime.append(i)print(sum(prime))def thread_10():jobs = []for i in range(1,100001,10000):t = Prime(i,i+10000)jobs.append(t)t.start()[i.join() for i in jobs]begin = time.time() # thread_4() # 用時: 12.594112157821655 thread_10() # 用時: 12.398741960525513 print("用時:",time.time() - begin)進程線程的區別聯系
1. 兩者都是多任務編程方式，都能使用計算機多核資源 2. 進程的創建刪除消耗的計算機資源比線程多 3. 進程空間獨立，數據互不干擾，有專門通信方法；線程使用全局變量通信 4. 一個進程可以有多個分支線程，兩者有包含關系 5. 多個線程共享進程資源，在共享資源操作時往往需要同步互斥處理 6. Python線程存在GIL問題，但是進程沒有。使用場景
總結
- 上一篇： 3分钟掌握7个XD基础操作
- 下一篇： 熊绎：我看软件工程师的职业规划（转载）