python 多工程式設計

多工：在同一時間內執行多個任務

多工的目的：多工的最大好處是充分利用cpu資源，提高程式的執行效率

併發:在一段時間內交替執行多個任務

並行:在同一時刻同時執行多個任務

程序：執行中的程式，分配資源的最小單位

執行緒：使用資源的最小單位

程序和執行緒的關係：乙個程式執行後至少有乙個程序，每個程序預設有乙個執行緒

多程序的使用流程：

匯入程序模組(multiprocessing)

import multiprocessing

建立子程序物件

sub_process = multiprocessing.process(group=none, target=none, name=none, args, kwargs)

# 其中：args 方式傳參應注意引數順序一致，kwargs 傳參應注意字典的 key 與引數名一致

啟動子程序

sub_process.start() #啟動子程序

sub_process.join() # 程序等待
sub_process.terminate() # 終止子程序
multiprocessing.current_process() #檢視當前程序
os.getpid() # 檢視程序編號
os.getppid() # 檢視父程序編號
os.kill(程序編號，9) # 根據程序編號強制殺死程序
print(a, b, c) # 可以直接列印變數 a b c
# 程序的執行是無序的，不依賴**的先後順序

例項：

# 單程序

import time
def dance():
for i in range(5):
time.sleep(1)
print("dance", i)
def sing():
for i in range(5):
time.sleep(1)
print("sing", i)
if __name__ == '__main__':
dance()
sing()
［執行結果］
[done] exited with code=0 in 10.052 seconds

# 多程序

import time
# 匯入程序模組
import multiprocessing
def dance():
for i in range(5):
time.sleep(1)
print("dance", i)
def sing():
for i in range(5):
time.sleep(1)
print("sing", i)
if __name__ == '__main__':
# 建立子程序
my_dance = multiprocessing.process(target=dance)
my_sing = multiprocessing.process(target=sing)
# 啟動子程序
my_dance.start()
my_sing.start()
［執行結果］
[done] exited with code=0 in 5.095 seconds

目的: 知道子程序是由哪個主程序建立的(子程序需要主程序**資源)

​os.getpid(): 表示獲取當前程序編號

​os.getppid(): 表示獲取當前父程序編號

程序名字

程序起名字

my_dance = multiprocessing.process(target=dance, name="my_processname")

獲取程序的名字

multiprocessing.current_process()

# 執行結果

程序引數

帶有引數的函式:

args: 元組!!!(單個元素的元組有 , )
my_dance = multiprocessing.process(target=dance, args=(5,))
kwargs: 字典!!!(key值要和函式中的形參完全重名)
my_dance = multiprocessing.process(target=dance, kwargs=)

程序之間不共享全域性變數，是因為操作的不是同乙個程序裡面的全域性變數，只不過不同程序裡面的全域性變數名字相同而已

import multiprocessing

import time
# 全域性變數列表
g_num = 
def my_write(): # 向全域性變數g_num裡寫入資料
global g_num
for i in range(5):
print("my_write:", g_num)
def my_read(): #讀取全域性變數g_num的值
global g_num
print("my_read:", g_num)
if __name__ == '__main__':
sub_write = multiprocessing.process(target=my_write)
sub_read = multiprocessing.process(target=my_read)
sub_write.start()
time.sleep(1) # 保證資料寫入g_num中
sub_read.start()
［執行結果］
my_write: [0, 1, 2, 3, 4]
my_read:

為了保證子程序能夠正常的執行，主程序會等所有的子程序執行完成以後再銷毀

設定守護主程序或銷毀主程序的目的是主程序退出子程序銷毀，不讓主程序再等待子程序去執行

多執行緒使用流程

匯入執行緒模組(threading)

建立子執行緒

開始子執行緒 例項

import time

# 匯入執行緒模組
import threading
def dance():
for i in range(5):
time.sleep(1)
print("dance", i)
def sing():
for i in range(5):
time.sleep(1)
print("sing", i)
if __name__ == '__main__':
# 建立子程序
my_dance = threading.thread(target=dance)
my_sing = threading.thread(target=sing)
# 啟動子程序
my_dance.start()
my_sing.start()
［執行結果］
[done] exited with code=0 in 5.042 seconds

守護主線程​

主線程會等待子執行緒的結束而結束

設定守護主線程的兩種方式：

執行緒引數(同程序)

執行緒之間共享全域性變數

好處是可以對全域性變數的資料進行共享

但是可能會導致資料出現錯誤問題

import threading

import time
g_num = 
def my_write():
global g_num
for i in range(5):
print("my_write:", g_num)
def my_read():
global g_num
print("my_read:", g_num)
if __name__ == '__main__':
sub_write = threading.thread(target=my_write)
sub_read = threading.thread(target=my_read)
sub_write.start()
time.sleep(1)
sub_read.start()
［執行結果］
my_write: [0, 1, 2, 3, 4]
my_read: [0, 1, 2, 3, 4]

執行緒同步: 保證同一時刻只能有乙個執行緒去操作全域性變數 同步: 就是協同步調，按預定的先後次序進行執行。

執行緒同步的方式:

Python 多工網路程式設計

提高效能的多工程式設計 可以用單執行緒 單程序 非堵塞併發的方法來實現多工，socket.setblocking false 將套接字變為非堵塞，會讓accept在沒有客戶端到來之前和socket.recv 沒有收到資料的時候從堵塞變為異常，從而我們可以讓它丟擲異常，繼續執行下面的 我們可以新建乙個...

python 多工程式設計 程序

程序 想要實現多工可以使用程序來完成，概念 乙個正在執行的程式或者軟體就是乙個程序，它是作業系統進行資源發呢排的基本單位 乙個程式執行後至少有乙個程序，乙個程序預設有乙個執行緒，程序裡面可以建立多個執行緒，執行緒依附在程序裡面的，沒有程序就沒有執行緒。程序的使用 1 匯入程序包 import mul...

多工網路程式設計

1 include 2 include 3 include 4 include 5 include in.h 6 include 7 include link.h 8 9 define port 8888 10int main void 11 31 sin.sin family af inet fi...