範例詳解Python的程序,執行緒和協程

2022-03-11 19:01:50

前言

本文用Python範例闡述了一些關於程序、執行緒和協程的概念，由於水平有限，難免出現錯漏，敬請批評改正。

前提條件

熟悉Python基本語法熟悉Python操作程序、執行緒、協程的相關庫

實驗環境

Python 3.x （物件導向的高階語言）
Multiprocessing（Python庫）
Threading（Python庫）
Asyncio（Python庫）
Time（Python庫）
Random（Python庫）

程序

程序：程式執行在作業系統上的一個範例，就稱之為程序。程序需要相應的系統資源：記憶體、時間片、pid(程序號)。一個執行的程式（程式碼）就是一個程序，沒有執行的程式碼叫程式，程序是系統資源分配的最小單位，程序擁有自己獨立的記憶體空間，所以程序間資料不共用，開銷大。

建立程序步驟：

1.首先要匯入 multiprocessing 中的 Process；

2.建立一個 Process 物件；

3.建立 Process 物件時，可以傳遞引數；

4.使用 start()啟動程序；

5.結束程序。

import os 
from multiprocessing import Process
import time
def pro_func(name,age,**kwargs):
	print("程序正在執行,name=%s, age=%d, pid=%d" %(name, age, os.getpid()))
	print('kwargs引數值',kwargs)
	time.sleep(0.1)
if __name__=="__main__":
    p=Process(target=pro_func,args=('Friendship',18),kwargs={'愛好':'Python'})
    print('啟動程序')
    p.start()
    print('程是否還在活著:',p.is_alive())# 判斷程序程序是否還在活著
    time.sleep(0.5)
    # 1 秒鐘之後，立刻結束程序
    print('結束程序')
    p.terminate() # 不管任務是否完成，立即終止程序
    p.join() # 等待子程序執行結束
    print('程是否還在活著:',p.is_alive())# 判斷程序程序是否還在活著

注意：程序間不共用全域性變數。

多程序

以一個讀寫程式為例，main函數為一個主程序，write函數為一個子程序，read函數為另一個子程序，然後兩個子程序進行讀寫操作。

import os
import time
import random
from multiprocessing import Process,Queue
# 寫資料函數
def write(q):
    for value in ['I','love','Python']:
        print('在佇列裡寫入 %s ' % value)
        q.put(value)
        time.sleep(random.random())
# 讀資料函數
def read(q):
    while True:
        if not q.empty():
            value  = q.get(True)
            print('從佇列中讀取 %s ' % value)
            time.sleep(random.random())
        else:
            break
if __name__=="__main__": # 主程序
    # 主程序建立 Queue，並傳給各個子程序
    q=Queue()
    # 建立兩個程序
    pw=Process(target=write,args=(q,))
    pr=Process(target=read,args=(q,))
    # 啟動子程序 pw
    pw.start()
    # 等待 pw結束
    pw.join()
    # 啟動子程序 pr
    pr.start()
    # 等待 pw結束
    pr.join()
    print('End!')

用程序池對多程序進行操作

from multiprocessing import Manager,Pool
import os,time,random
def read(q):
    print("read程序 啟動(%s),主程序為(%s)" % (os.getpid(), os.getppid()))
    for i in range(q.qsize()):
        print("read程序 從 Queue 獲取到訊息：%s" % q.get(True))
def write(q):
    print("write程序 啟動(%s),主程序為(%s)" % (os.getpid(), os.getppid()))
    for i in "Python":
        q.put(i)
if __name__=="__main__":
    print("主程序(%s) start" % os.getpid())
    q = Manager().Queue() # 使用 Manager 中的 Queue
    # 定義一個程序池
    po = Pool()
    # Pool().apply_async(要呼叫的目標,(傳遞給目標的引數元祖,))
    po.apply_async(write, (q,))
    time.sleep(1) # 先讓上面的任務向 Queue 存入資料，然後再讓下面的任務開始從中取資料
    po.apply_async(read, (q,))
    po.close() # 關閉程序池，關閉後 po 不再接收新的請求
    po.join() # 等待 po 中所有子程序執行完成，必須放在 close 語句之後
    print("(%s) End!" % os.getpid())

執行緒

執行緒：排程執行的最小單位，也叫執行路徑，不能獨立存在，依賴程序存在一個程序至少有一個執行緒，叫主執行緒，而多個執行緒共用記憶體(資料共用，共用全域性變數)，從而極大地提高了程式的執行效率。

上圖，紅框表示程序號(PID)為1624的程序，有118個執行緒。

使用_thread模組實現

import _thread
import time
import random
# 為執行緒定義一個函數
def print_time(threadName):
    count = 0
    while count < 5:
        time.sleep(random.random())
        count += 1
        print ("%s: %s" % (threadName, time.ctime(time.time())))
# 建立兩個執行緒
try:
    _thread.start_new_thread(print_time, ("Thread-1",))
    _thread.start_new_thread(print_time, ("Thread-2",))
except:
    print ("Error: 無法啟動執行緒")
while True:
	pass

使用 threading 模組實現

# 使用 threading 模組建立執行緒 
import threading
import time
import random
class myThread(threading.Thread):
    def __init__(self, threadID, name):
        threading.Thread.__init__(self)
        self.threadID = threadID
        self.name = name
        self.delay = random.random()
    def run(self):
        print ("開始執行緒：" + self.name)
        print_time(self.name, 5)
        print ("退出執行緒：" + self.name)
def print_time(threadName, count):
    while count:
        time.sleep(random.random())
        print ("%s: %s" % (threadName, time.ctime(time.time())))
        count -= 1
# 建立兩個執行緒
thread1 = myThread(1, "Thread-1")
thread2 = myThread(2, "Thread-2")
# 開啟新執行緒
thread1.start()
thread2.start()
thread1.join()
thread2.join()
print ("退出主執行緒")

協程

協程：是一種使用者態的輕量級執行緒，協程的排程完全由使用者控制。協程擁有自己的暫存器上下文和棧。協程排程切換時，將暫存器上下文和棧儲存到其他地方，在切回來的時候，恢復先前儲存的暫存器上下文和棧，直接操作棧則基本沒有核心切換的開銷，可以不加鎖的存取全域性變數，所以上下文的切換非常快。
當出現IO阻塞的時候，由協程的排程器進行排程，通過將資料流立刻yield掉(主動讓出)，並且記錄當前棧上的資料，阻塞完後立刻再通過執行緒恢復棧，並把阻塞的結果放到這個執行緒上去跑，這樣看上去好像跟寫同步程式碼沒有任何差別，這整個流程可以稱為coroutine。
由於協程的暫停完全由程式控制，發生在使用者態上;而執行緒的阻塞狀態是由作業系統核心來進行切換，發生在核心態上。因此，協程的開銷遠遠小於執行緒的開銷。

使用asyncio模組實現

import asyncio
import time
import random
async def work(msg):
    print("收到的資訊:'{}'".format(msg))
    print("{}1{}".format("*"*10,"*"*10)) # 為了方便，展示結果
    await asyncio.sleep(random.random())
    print("{}2{}".format("*"*10,"*"*10)) # 為了方便，展示結果
    print(msg)
async def main():
	# 建立兩個任務物件(協程)，並加入到事件迴圈中
    Coroutines1 = asyncio.create_task(work("hello"))
    Coroutines2 = asyncio.create_task(work("Python"))
    print("開始時間: {}".format(time.asctime(time.localtime(time.time()))))
    await Coroutines1  # 此時並行執行Coroutines1和Coroutines2
    print("{}3{}".format("*"*10,"*"*10)) # 為了方便，展示結果
    await Coroutines2 # await相當於掛起當前任務，去執行其他任務，此時是堵塞的
    print("{}4{}".format("*"*10,"*"*10)) # 為了方便，展示結果
    print("結束時間:{}".format(time.asctime(time.localtime(time.time()))))
asyncio.run(main())# asyncio.run(main())建立一個事件迴圈，並以main為主要程式入口

總結

程序：一個執行的程式（程式碼）就是一個程序，沒有執行的程式碼叫程式，程序是系統資源分配的最小單位，程序擁有自己獨立的記憶體空間，所以程序間資料不共用，開銷大。
執行緒：排程執行的最小單位，也叫執行路徑，不能獨立存在，依賴程序存在一個程序至少有一個執行緒，叫主執行緒，而多個執行緒共用記憶體(資料共用，共用全域性變數)，從而極大地提高了程式的執行效率。
協程：是一種使用者態的輕量級執行緒，協程的排程完全由使用者控制。協程擁有自己的暫存器上下文和棧。協程排程切換時，將暫存器上下文和棧儲存到其他地方，在切回來的時候，恢復先前儲存的暫存器上下文和棧，直接操作棧則基本沒有核心切換的開銷，可以不加鎖的存取全域性變數，所以上下文的切換非常快。

本篇文章就到這裡了，希望能夠給你帶來幫助，也希望您能夠多多關注it145.com的更多內容!