Python3 学习笔记线程、进程、协程

一、线程

from threading import Thread    #线程类
# 多线程方式一
def fn(name):
    for i in range(10):
        print('线程{}'.format(name),i)

if __name__ == '__main__':
    t = Thread(target=fn,args=("jj",))    # target 指定任务名称， args:传入参数，必须为数组类型，后边的逗号不能缺
    t.start()    #指定多线程状态为可执行状态，具体执行时间又CPU决定
    for i in range(20):
        print('main',i)

#多线程方式二
class myThread(Thread):
    def run(self):
        for i in range(10):
            print('子线程',i)

if __name__ == '__main__':
    t = myThread()
    t.start()     #千万不要t.run()  --》方法调用，单线程
    for i in range(10):
        print('main',i)



# 线程池
from concurrent.futures import ThreadPoolExecutor      #线程池


def fn1(name):    #创建一个需要执行的任务，name:可传入参数
    for i in range(10):
        print(name,i)

if __name__ == '__main__':
    with ThreadPoolExecutor(3) as t:    #创建一个有3个线程的线程池
        for i in range(20):     #有20个任务
            t.submit(fn1, name = '线程{}'.format(i))  #将任务逐个提交到线程池

    print("Over !!!")   #等待线程池执行完成之后，才继续执行（守护）

二、进程

from multiprocessing import Process   #进程
#进程方法一
def fn(name):
    for i in range(10):
        print('子进程{}'.format(name),i)

if __name__ == '__main__':
    p = Process(target=fn,args=('jj',))
    p.start()
    p.join()
    for i in range(10):
        print('主进程',i)

#进程方法二
class myProcess(Process):
    def run(self):
        for i in range(10):
            print('子进程',i)

if __name__ == '__main__':
    p = myProcess()
    p.start()
    for i in range(10):
        print('主进程',i)

#进程池
from concurrent.futures import ProcessPoolExecutor   #进程池


def fn(name,name1):
    for i in range(10):
        print('子进程{}'.format(name),i,name1)


if __name__ == '__main__':
    with ProcessPoolExecutor(max_workers=10) as p:
        for i in range(20):
            p.submit(fn,name=i,name1='b')  #传递参数
    print("Over !!!")   #等待进程池执行完成之后，才继续执行（守护）

三、协程

介绍：为了保证CPU一直处理想要处理的程序，而不是去处理和程序无关的其他事务。

import asyncio
import time

async def func1():    #函数前加 async 切换为异步函数
    print("hello 11")
    await asyncio.sleep(3)    #异步操作的代码在此处。 比如：requests.get()    await:表示后台挂起，释放CPU
    print("hello 11")

async def func2():
    print("hello 22")
    await asyncio.sleep(2)
    print("hello 22")

async def func3():
    print("hello 33")
    await asyncio.sleep(4)
    print("hello 33")

async def main():
    # tasks = [func1(),func2(),func3()]  #func1() 此时的函数是异步协程函数，函数执行得到的是一个协程对象
    # await asyncio.wait(tasks)    #
    # #在python 3.8 以后的版本 使用以上方式会报错，推荐直接使用以下方式，代码如下
    tasks = [
        asyncio.create_task(func1()),
        asyncio.create_task(func2()),
        asyncio.create_task(func3())
    ]
    await asyncio.wait(tasks)    #必须使用await 挂起任务，否则报错

if __name__ == '__main__':
    t1 = time.time()
    asyncio.run(main())   #协程程序运行需要 asyncio模块支持， 此处为执行任务列表的固定搭配
    t2 = time.time()
    print(t2 - t1)  #如果串行了至少需要9秒， 通过协程处理后只需要4秒多。