Python 多任务（线程、进程、协程）
多任务：同时执行多个事件（多个任务）
并发：CPU小于当前的执行任务。
并行：CPU大于当前执行的任务。
实现多任务的方式：线程、进程、协程
1.线程
线程（thread）是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。
#使用线程完成多任务
import threading # 内置模块
import time
def demo():
for i in range(3):
print("hello world")
time.sleep(1)
if __name__ == '__main__':
t = threading.Thread(target=demo)
t.start()
print("1")
#主线程会等到子线程执行结束之后主线程，才会结束
防护线程：守护线程，也就是说不会等子线程结束
使用方法： t.setDaemon(True)
那是否可以实现子线程结束完毕，主线程才继续执行呢？
使用方法：t.join()
查看线程数量
使用threading.enumerate()来查看当前线程的数量。
import threading
import time
def demo1():
for i in range(3):
print(f"--demo1--{i}")
time.sleep(1)
def demo2():
for i in range(3):
print(f"--demo2--{i}")
time.sleep(1)
def main():
t1 = threading.Thread(target=demo1)
t2 = threading.Thread(target=demo2)
t1.start()
t2.start()
print(threading.enumerate())
if __name__ == '__main__':
main()
验证子线程的执行与创建：
当调用Thread的时候，不会创建线程。
当调用Thread创建出来的实例对象的start方法的时候，才会创建线程以及开始运行这个线程。
继承Thread类创建线程
import threading
import time
class A(threading.Thread):
def __init__(self,name):
super().__init__(name=name)
def run(self):
for i in range(5):
print(i)
if __name__ == "__main__":
t = A('test_name')
t.start()
多线程共享全局变量(线程间通信)
import threading
import time
num = 100
def demo1():
global num # 2.声明为全局变量
num += 1 # 1.函数作用域 访问不到外边的num 所以报错 找不到
print(f"demo----{num}")
def demo2():
print(f"demo1----{num}")
def main():
t1 = threading.Thread(target=demo1)
t2 = threading.Thread(target=demo2)
t1.start()
time.sleep(1)
t2.start()
time.sleep(1)
if __name__ == '__main__':
main()
多线程之间传参
import threading
import time
num = [11, 22]
def demo1(num):
num.append(33)
print(f"demo----{num}" )
def demo2(num):
print(f"demo1----{num}")
def main():
t1 = threading.Thread(target=demo1, args=(num,))
t2 = threading.Thread(target=demo2, args=(num,))
t1.start()
time.sleep(1)
t2.start()
time.sleep(1)
print(f"main----{num}")
2.线程与进程
互斥锁
当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制
某个线程要更改共享数据时，先将其锁定，此时资源的状态为"锁定",其他线程不能改变，只到该线程释放资源，将资源的状态变成"非锁定"，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。
# 创建锁
mutex = threading.Lock()
# 锁定
mutex.acquire()
# 解锁
mutex.release()
死锁
在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁。
import threading
import time
class MyThread1(threading.Thread):
def run(self):
# 对mutexA上锁
mutexA.acquire()
# mutexA上锁后，延时1秒，等待另外那个线程 把mutexB上锁
print(self.name+'----do1---up----')
time.sleep(1)
# 此时会堵塞，因为这个mutexB已经被另外的线程抢先上锁了
mutexB.acquire()
print(self.name+'----do1---down----')
mutexB.release()
# 对mutexA解锁
mutexA.release()
class MyThread2(threading.Thread):
def run(self):
# 对mutexB上锁
mutexB.acquire()
# mutexB上锁后，延时1秒，等待另外那个线程 把mutexA上锁
print(self.name+'----do2---up----')
time.sleep(1)
# 此时会堵塞，因为这个mutexA已经被另外的线程抢先上锁了
mutexA.acquire()
print(self.name+'----do2---down----')
mutexA.release()
# 对mutexB解锁
mutexB.release()
mutexA = threading.Lock()
mutexB = threading.Lock()
if __name__ == '__main__':
t1 = MyThread1()
t2 = MyThread2()
t1.start()
t2.start()
避免死锁：程序设计时要尽量避免，添加超时时间等
线程同步
我们使用 threading.Condition() 完成线程同步。
# 线程同步
cond = threading.Condition()
# 等待
cond.wait()
# 唤醒
cond.notify()
进程
定义
进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。并且进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。
概念
• 进程是一个实体。每一个进程都有它自己的地址空间，一般情况下，包括文本区域（text region）、数据区域（data region）和堆栈（stack region）。
• 进程是一个“执行中的程序”。
• 进程是操作系统中最基本、重要的概念。
进程与程序区别
• 进程：正在执行的程序。动态的，暂时的
• 程序：没有执行的代码，是一个静态的，永久的
进程状态介绍
Python实现多进程
通过 multiprocessing.Process模块
• group：参数未使用，默认值为None。
• target：表示调用对象，即子进程要执行的任务。
• args：表示调用的位置参数元祖。
• kwargs：表示调用对象的字典。
• name：子进程名称
import multiprocessing
import time
def demo():
while True:
print("--1--")
time.sleep(1)
if __name__ == '__main__':
p1 = multiprocessing.Process(target=demo)
p1.start()
#注意：多个进程同时执行的顺序是随机的。
通过继承Process类创建进程
class Demo(multiprocessing.Process):
def run(self):
while True:
print("--1--")
time.sleep(1)
if __name__ == '__main__':
p1 = Demo()
p1.start()
守护主线程
class Demo(multiprocessing.Process):
def run(self):
while True:
print("--1--")
time.sleep(1)
if __name__ == '__main__':
p1 = Demo()
p1.daemon = True
p1.start()
print("1")
子线程结束，再执行主线程
class Demo(multiprocessing.Process):
def run(self):
while True:
print("--1--")
time.sleep(1)
if __name__ == '__main__':
p1 = Demo()
p1.start()
p1.join()
print("1")
进程与线程区别
- 根本区别
进程：操作系统资源分配的基本单位
线程：任务调度和执行的基本单位 - 开销
• 进程：通过复制代码+资源创建子进程 每个进程都有独立的代码和数据空间，程序之间的切换会有较大的开销
• 线程：在同一份代码里 创建线程 共享内存 开销较小 - 分配内存
• 进程：系统在运行的时候为每个进程分配不同的内存空间
• 线程：线程所使用的资源是它所属的进程的资源 - 包含关系
• 进程：一个进程可以拥有多个线程
• 线程：线程是进程的一部分
3.进程
多进程共享全局变量
import threading
import time
import multiprocessing
num = 100
def demo1():
global num
num += 1
print(f"demo----{num}")
def demo2():
print(f"demo1----{num}")
p1 = multiprocessing.Process(target=demo1)
p2 = multiprocessing.Process(target=demo2)
p1.start()
p2.start()
if __name__ == '__main__':
main()
进程间的通信
这个时候就可以使用到队列进行通信。
需求：
• 实现在函数 download 中，将list元素保存到队列中
• 实现在函数 manage_data 中，将list元素从队列中取出，并且添加到新的列表中。
import multiprocessing
# 下载数据
def download(q):
lis = [11, 22, 33]
for item in lis:
q.put(item)
print("下载完成，并且保存到队列中...")
# 处理数据
def manage_data(q):
ana_data = list()
while True:
data = q.get()
ana_data.append(data)
if q.empty():
break
print(ana_data)
def main():
q = multiprocessing.Queue()
t1 = multiprocessing.Process(target=download, args=(q,))
t2 = multiprocessing.Process(target=manage_data, args=(q,))
t1.start()
t2.start()
if __name__ == '__main__':
main()
注意：如果使用普通队列，不是使用 start() 方法，而是 run() 方法。
start() 与 run() 区别
• start() 方法来启动进程，真正实现了多进程运行，这时无需等待 run 方法体代码执行完毕而直接继续执行下面的代码：调用 Process 类的 start() 方法来启动一个进程，这时此进程处于就绪（可运行）状态，并没有运行，一旦得到 cpu 时间片，就开始执行 run() 方法，这里方法 run() 称为进程体，当进程结束后，不可以重新启动。
• run() 方法只是类的一个普通方法，如果直接调用 run 方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待 run 方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的。
进程池
当需要创建的子进程数量不多时，可以直接利用 multiprocessing 中的 Process 动态生成多个进程， 但是如果是上百甚至上千个目标，手动的去创建的进程的工作量巨大，此时就可以用到 multiprocessing 模块提供的 Pool 方法。也就是进程池。
初始化 Pool 时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求，但是如果进程池中的进程已经达到指定的最大值，那么该请求 就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务。
如下代码，使用进程池体现。
import os, time
def worker(msg):
t_start = time.time()
print(f"{msg}开始执行，进程号为{os.getpid()}")
time.sleep(2)
t_stop = time.time()
print(msg, f"执行完成，耗时{t_stop-t_start}")
worker()
进程池通信
使用进程池通信时，要使用进程池的队列。
• multiprocessing.Manager().Queue()
import multiprocessing
def demo1(q):
q.put("a")
def demo2(q):
data = q.get()
print(data)
if __name__ == '__main__':
q = multiprocessing.Manager().Queue()
po = multiprocessing.Pool(2)
po.apply_async(demo1, args=(q,))
po.apply_async(demo2, args=(q,))
po.close()
po.join()
4.协程
协程，又称为微线程，它是实现多任务的另一种方式，只不过是比线程更小的执行单元。因为它自带CPU的上下文，这样只要在合适的时机，我们就可以把一个协程切换到另一个协程。
CPU上下文(CPU寄存器和程序计数器)：
• CPU寄存器是CPU的内置的容量小，但速度极快的内存。
• 程序计数器则是用来存储CPU正在执行的指令位置、或者即将执行的下一条指令位置。
协程与线程差异
• 线程：每个线程都有自己缓存Cache等等数据，操作系统还会做这些数据的恢复操作。所以线程的切换非常消耗性能。
• 协程：单纯的操作CPU的上下文，所以一秒切换上百万次系统都能抗住。所以完成多任务的效率比线程和进程都高
yield实现协程
import time
def task1():
while True:
print("--1--")
time.sleep(0.1)
yield
def task2():
while True:
print("--2--")
time.sleep(0.1)
yield
def main():
t1 = task1()
t2 = task2()
while True:
next(t1)
next(t2)
if __name__ == '__main__':
main()
生成器扩展
• next(g)预激活
• g.send(None)预激活
• g.send(“需发送的值”)激活yield并且发送值
• 注意：此前必须有预激活也就是next(g)或g.send(None)
• 生成器函数的返回值在异常中
def create_num(num):
a, b = 0, 1
current_num = 0
while current_num < num:
yield a
a, b = b, a + b
current_num += 1
return 'hello world'
g = create_num(5)
yield from
作用：
• 1.替代产出值的嵌套for循环
• 2.yield from的主要功能是打开双向通道，把最外层的调用方与最内层的子生成器连接起来。因为yield from的异常捕获更为完善。
替代产出值的嵌套for循环
需求
lis = [1, 2, 3]
dic = {
"name":"amy",
"age":18
}
输出：
1
2
3
name
age
实现
def my_chain(*args, **kwargs):
for my_iterable in args:
yield from my_iterable
for value in my_chain(lis, dic):
print(value)
yield from的主要功能是打开双向通道
def generator_1():
total = 0
while True:
x = yield
print("加", x)
if not x:
break
total += x
return total
def main():
g1 = generator_1()
g1.send(None)
g1.send(2)
g1.send(3)
g1.send(None)
if __name__ == '__main__':
main()
greenlet实现协程
from greenlet import greenlet #greenlet库 需要安装
import time
def demo1():
while True:
print("demo1")
gr2.switch()
time.sleep(0.5)
def demo2():
while True:
print("demo2")
gr1.switch()
time.sleep(0.5)
if __name__ == '__main__':
gr1 = greenlet(demo1)
gr2 = greenlet(demo2)
gr1.switch()
gevent实现协程
介绍
greenlet已经实现了协程，但是这个还的人工切换，就很麻烦，python还有一个比greenlet更强大的并且能够自动切换任务的模块gevent
原理： 当一个greenlet遇到IO操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行
由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO
import gevent
import time
def f1(n):
for i in range(n):
print(gevent.getcurrent(),i)
gevent.sleep(0.5)
def f2(n):
for i in range(n):
print(gevent.getcurrent(),i)
gevent.sleep(0.5)
g1 = gevent.spawn(f1, 5) # 创建协程
g2 = gevent.spawn(f2, 5)
g1.join()
g2.join()
异步编程
同步与异步
同步：是指代码调用IO操作时,必须等待IO操作完成才返回的调用方式,多个任务之间执行的时候要求有先后顺序，必须一个先执行完成之后，另一个才能继续执行， 只有一个主线
异步：是指代码调用IO操作时,不必等IO操作完成就返回的调用方式,多个任务之间执行没有先后顺序，可以同时运行，执行的先后顺序不会有什么影响，存在的多条运行主线
async/await实现协程
Python中使用协程最常用的库就是asyncio
• async/await 关键字：python3.5用于定义协程的关键字，async定义一个协程，await用于挂起阻塞的异步调用接口。
• coroutine 协程：协程对象，只一个使用async关键字定义的函数，他的调用不会立即执行函数，而是会返回一个协程对象。协程对象需要注册到事件循环中，由事件循环调用。
• event_loop 事件循环：相当于一个无限循环，我们可以把一些函数注册到这个事件循环上，当满足条件时，就会调用对应的处理方法。
• task 任务：一个协程对象就是一个原生可以挂起的函数，任务则是对协程的进一步封装，其中包含任务的各种状态。
• future：代表将来执行或没有执行的任务结果。它与task没有本质的区别。
快速上手
协程函数，定义函数时候 async def 函数名 。
协程对象，执行 协程函数() 得到的协程对象。
async def func():
pass
result = func()
如果想要运行协程函数内部代码，必须要讲协程对象交给事件循环来处理。
import asyncio
async def func():
print("快来搞我吧！")
result = func()
loop = asyncio.get_event_loop()
loop.run_until_complete( result )
await
import asyncio
async def func():
print("来呀")
response = await asyncio.sleep(2)
print("结束",response)
result = func()
loop = asyncio.get_event_loop()
loop.run_until_complete( result )
Tasks
Tasks用于并发调度协程，通过asyncio.create_task(协程对象)的方式创建Task对象，这样可以让协程加入事件循环中等待被调度执行。除了使用asyncio.create_task()函数以外，还可以用低层级的loop.create_task()或 ensure_future() 函数。不建议手动实例化 Task 对象。
注意：asyncio.create_task()函数在 Python 3.7 中被加入。在 Python 3.7 之前，可以改用低层级的 asyncio.ensure_future()函数。
import asyncio
async def func():
print(1)
await asyncio.sleep(2)
print(2)
return "返回值"
async def main():
print("main开始")
task1 = asyncio.ensure_future( func() )
task2 = asyncio.ensure_future( func() )
print("main结束")
ret1 = await task1
ret2 = await task2
print(ret1, ret2)
result = main()
loop = asyncio.get_event_loop()
loop.run_until_complete( result )
简单总结
• 进程是资源分配的单位
• 线程是操作系统调度的单位
• 进程切换需要的资源很最大，效率很低
• 线程切换需要的资源一般，效率一般
• 协程切换任务资源很小，效率高
• 多进程、多线程根据cpu核数不一样可能是并行的，但是协程是在一个线程中 所以是并发