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核心数开启多少个进程