深入瞭解Python 中執行緒和程序區別

from threading import Thread

import time, queue, threading


class MyThread(threading.Thread):

    def __init__(self):
        super().__init__()
        self.daemon = True  # 開啟守護模式
        self.queue = queue.Queue(3)  # 開啟佇列物件，儲存三個任務
        self.start()  # 範例化的時候直接啟動執行緒，不需要手動啟動執行緒

    def run(self) -> None:  # run方法執行緒自帶的方法,內建方法，線上程執行時會自動呼叫
        while True:  # 不斷處理任務
            func, args, kwargs = self.queue.get()
            func(*args, **kwargs)  # 呼叫函數執行任務 元組不定長記得一定要拆包
            self.queue.task_done()  # 解決一個任務就讓計數器減一，避免阻塞

    # 生產者模型
    def submit_tasks(self, func, args=(), kwargs={}):  # func為要執行的任務，加入不定長引數使用（預設使用預設引數）
        self.queue.put((func, args, kwargs))  # 提交任務

    # 重寫join方法
    def join(self) -> None:
        self.queue.join()  # 檢視佇列計時器是否為0 任務為空 為空關閉佇列
        
        
def f2(*args, **kwargs):
    time.sleep(2)
    print("任務2完成", args, kwargs)

# 範例化執行緒物件
mt = MyThread()
# 提交任務
mt.submit_tasks(f2, args=("aa", "aasd"), kwargs={"a": 2, "s": 3})

# 讓主執行緒等待子執行緒結束再結束
mt.join()

def f2(i):
    time.sleep(2)
    print("任務2完成", i)

lis = []
for i in range(5):
    t = Thread(target=f2, args=(i,))
    t.start()  # 啟動 5 個執行緒
    lis.append(t)

for i in lis:
    i.join()  # 執行緒等待

import threading

var = 1
# 新增互斥鎖，並且拿到鎖
lock = threading.Lock()

# 定義兩個執行緒要用做的任務
def func1():
    global var  # 宣告全域性變數
    for i in range(1000000):
        lock.acquire()  # 操作前上鎖
        var += i
        lock.release()  # 操作完後釋放鎖
        
def func2():
    global var  # 宣告全域性變數
    for i in range(1000000):       
        lock.acquire()  # 操作前上鎖    
        var -= i
        lock.release()  # 操作完後釋放鎖
        
# 建立2個執行緒
t1 = threading.Thread(target=func1)
t2 = threading.Thread(target=func2)
t1.start()
t2.start()
t1.join()
t2.join()
print(var)

import time
from multiprocessing import Process


class MyProcess(Process):  # 繼承Process類
    def __init__(self, target, args=(), kwargs={}):
        super(MyProcess, self).__init__()
        self.daemon = True  # 開啟守護行程
        self.target = target
        self.args = args
        self.kwargs = kwargs
        self.start()  # 自動開啟程序

    def run(self):
        self.target(*self.args, **self.kwargs)


def fun(*args, **kwargs):
    print(time.time())
    print(args[0])


if __name__ == '__main__':
    lis = []
    for i in range(5):
        p = MyProcess(fun, args=(1, ))
        lis.append(p)
    for i in lis:
        i.join()  # 讓程序等待

import time
from multiprocessing import  Process

def fun(*args, **kwargs):
    print(time.time())
    print(args[0])

if __name__ == '__main__':
    lis = []
    for i in range(5):
        p = Process(target=fun, args=(1, ))
        lis.append(p)
    for i in lis:
        i.join()  # 讓程序等待

from multiprocessing import Process, Lock, Manager

def f(n, d, l, lock):
    lock.acquire()
    d[str(n)] = n
    l[n] = -99
    lock.release()

if __name__ == '__main__':
    lock = Lock()
    with Manager() as manager:
        d = manager.dict()  # 空字典
        l = manager.list(range(10))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
        # 啟動10個程序，不同的程序對d和l中的不同元素進行操作
        for i in range(10):
            p = Process(target=f, args=(i, d, l, lock))
            p.start()
            p.join()

        print(d)
        print(l)

from multiprocessing import cpu_count  # cpu核心數模組，其可以獲取 CPU 核心數

n = cpu_count()  # 獲取cpu核心數

from concurrent.futures import ThreadPoolExecutor
import threading
import time
# 定義一個準備作為執行緒任務的函數
def action(max):
    my_sum = 0
    for i in range(max):
        print(threading.current_thread().name + '  ' + str(i))
        my_sum += i
    return my_sum

# 建立一個包含2條執行緒的執行緒池
pool = ThreadPoolExecutor(max_workers=2)
# 向執行緒池提交一個task, 50會作為action()函數的引數
future1 = pool.submit(action, 50)
# 向執行緒池再提交一個task, 100會作為action()函數的引數
future2 = pool.submit(action, 100)
def get_result(future):
    print(future.result())
    
# 為future1新增執行緒完成的回撥函數
future1.add_done_callback(get_result)
# 為future2新增執行緒完成的回撥函數
future2.add_done_callback(get_result)
# 判斷future1代表的任務是否結束
print(future1.done())
time.sleep(3)
# 判斷future2代表的任務是否結束
print(future2.done())
# 檢視future1代表的任務返回的結果
print(future1.result())
# 檢視future2代表的任務返回的結果
print(future2.result())
# 關閉執行緒池
pool.shutdown()  # 序可以使用 with 語句來管理執行緒池，這樣即可避免手動關閉執行緒池

from concurrent.futures import ProcessPoolExecutor

pool = ProcessPoolExecutor(max_workers=cpu_count())  # 根據cpu核心數開啟多少個程序