协程相关的更新

Author: sola1121

04 多进程,多线程,协程/09 asyncio协程.txt

@@ -1,19 +1,20 @@
 协程 Coroutine
  协程或又叫微线程, 纤程, 协程本质是在一个线程内, 通过轮询的方式执行不同的任务.
+ 对比于进程与线程是系统CPU的能力, 协程是由程序员通过代码实现的, 其建立在系统的线程之上.
 
 工作原理
- 对比于进程与线程是系统CPU的能力, 协程是由程序员通过代码实现的, 其建立在系统的线程之上.
  通过应用层记录程序的上下文栈区, 实现程序运行中的跳跃. 进而实现选择代码段执行.
 
-一般一个线程栈大小为1MB, 使用多线程, 在高并发下, cpu大部分的时间都将用于切换线程上下文.
-由于线程的切换是在内核完成的, 会耗费额外的空间和时间. 而且由于内存都分配给线程栈了, 将频繁地进行内存置换算法, 浪费了很多cpu时间片.
-
-协程, 可以理解为一种在线程里跑的子线程, 它的默认栈空间很小 (比如go的协程栈默认大小为2KB). 
-当多个协程在一个线程上运行时, 协程间会切换着运行, 协程的切换完全在用户态完成, 而且时机由程序员来自行调度, 从而使得线程的并发量大大提升.
+协程的资源消耗
+ 一般一个线程栈大小为1MB, 使用多线程, 在高并发下, cpu大部分的时间都将用于切换线程上下文.
+ 由于线程的切换是在内核完成的, 会耗费额外的空间和时间. 而且由于内存都分配给线程栈了, 将频繁地进行内存置换算法, 浪费了很多cpu时间片.
 
-但要注意的是协程只适用于IO密集型程序(大部分时间在等待的), 对于计算密集型程序, 协程的优势并不大, 因为没有给它切换的时间, cpu大部分时间都在工作.
+ 对比协程, 可以理解为一种在线程里跑的子线程, 它的默认栈空间很小 (比如go的协程栈默认大小为2KB). 
+ 当多个协程在一个线程上运行时, 协程间会切换着运行, 协程的切换完全在用户态完成, 而且时机由程序员来自行调度, 从而使得线程的并发量大大提升.
 
-常见的IO密集型程序有 网络请求、文件读写、数据库查询等，
+ 但要注意的是协程只适用于IO密集型程序(大部分时间在等待的).
+ 对于计算密集型程序, 协程的优势并不大, 因为没有给它切换的时间, cpu大部分时间都在工作.
+ 常见的IO密集型程序有 网络请求、文件读写、数据库查询等，
 
 优点:
  无需多线程切换的开销
@@ -131,15 +132,42 @@ asyncio 标准库
  async 关键字: async定义一个协程.
  格式: async def 函数名(参数): pass
 
- await 关键字: 遇到阻塞后，先挂起当前协程（任务），让事件循环去执行其他任务（如果有的话），等待“可等待对象”执行完成后，再继续执行下面的代码。
- 格式: await 可等待对象
- 获取可等待对象的返回值
- 格式: 变量名 = await 可等待对象
+ await 关键字: 获取可等待对象的返回值, 若协程函数有返回值, 只有拿到返回值才会解除阻塞
+ 遇到阻塞后，先挂起当前协程（任务），让事件循环去执行其他任务（如果有的话），等待“可等待对象”执行完成后，再继续执行下面的代码。
+ 格式: await 可等待对象
+ 格式: 变量名 = await 可等待对象
+ 注意
+ await是用来等待任务返回结果的, 不是用来进行异步任务并发的
 
  可等待对象
  可等待对象是指可以在await语句中使用的对象，它主要有三种：协程对象、Task对象和 Future对象
 
- 2) 事件循环
+ 2) 协程对象
+ coroutine对象
+
+ 以async def 函数名(): pass 的格式定义的函数, 为协程函数, 当执行一个协程函数, 会返回一个协程对象.
+ 
+ 3) Task对象
+ Task对象用于向事件循环中加入任务.
+
+ Task用于开发调度协程, 通过asyncio.create_task(协程对象)创建(该函数于Python3.7中添加).
+ 也可以使用asyncio.ensure_future(协程对象)创建一个Task对象.
+
+ asyncio.run_until_complete的参数是一个future对象, 当传入一个协程, 其内部会自动封装成Task.
+
+ 在协程嵌套中
+ ret1 = await fun1()
+ ret2 = await fun2()
+ await仅会将fun1提交到事件循环中, fun2的await并未执行
+
+ 通过将协程对象变为Task对象, 使await不阻塞
+ task1 = asyncio.create_task(fun1())
+ task2 = asyncio.create_task(fun2())
+
+ ret1 = await task1
+ ret2 = await tssk2
+ Task对象不是阻塞的, await将会把这两个Task对象同时提交到任务循环中
+
 
  2) 运行协程的三种主要方式
  (1) 用asyncio.run()函数用来运行.

04 多进程,多线程,协程/py_process/09 协程/1_使用生成器完成多任务切换.py

@@ -0,0 +1,18 @@
+import time
+
+def fun_a():
+ while True:
+ print(f"{fun_a.__name__}调用")
+ yield
+ time.sleep(1)
+
+def fun_b(gen):
+ while True:
+ print(f"{fun_b.__name__}调用")
+ gen.__next__() # next(gen)
+
+# a 为fun_a函数的生成器, 将其给fun_b函数
+# fun_b函数将先执行, 打印fun_b调用, 然后获取生成器中的一个对象, 该对象调用, 将打印fun_a调用
+# 以上, 将会不断的交替执行, 这就是任务的切换
+a = fun_a()
+fun_b(a)

04 多进程,多线程,协程/py_process/09 协程/4_协程的使用.py

@@ -14,40 +14,41 @@ async def fun_work2(val):
 
 
 # 方式1
-# 使用另一个协程函数将要执行的协程闭包
+# 1) 使用另一个协程函数将要执行的协程闭包
 async def run_coro():
  await fun_work1(1) # 等待协程对象
  await fun_work2(2)
 
-# 使用事件循环执行协程对象
+# 2) 使用事件循环执行协程对象
 # 获取事件循环
 loop = asyncio.get_event_loop()
-# 通过事件循环执行轮询事件, 直到所有的协程对象都完成
+# 3) 通过事件循环执行轮询事件, 直到所有的协程对象都完成
 loop.run_until_complete(run_coro()) # 运行协程函数将会获得一个协程对象
 # 关闭事件循环
 loop.close()
 
 
 # 方式2
-# 使用另一个协程函数将要执行的协程闭包
+# 1) 使用另一个协程函数将要执行的协程闭包
 async def do_coro2():
  tasks = [
  asyncio.create_task(fun_work1(11)), # 将协程对象变成Task对象
  asyncio.create_task(fun_work2(12))
  ]
  await asyncio.wait(tasks) # 异步等待, 等待所有的任务对象完成
 
-# 使用run函数省略事件循环, 直接执行 协程对象, Task对象 或 Future对象
+# 2) 使用run函数省略事件循环, 直接执行 协程对象, Task对象 或 Future对象
 asyncio.run(do_coro2())
 
 
 # 方式3
-# 将要执行的协程写入一个列表
+# 1) 将要执行的协程对象写入一个列表
 tasks = [
  fun_work1(101),
  fun_work2(102),
 ]
 
-# 使用run函数省略事件循环, 直接执行 协程对象, Task对象 或 Future对象
+# 2) 使用run函数省略事件循环, 直接执行 协程对象, Task对象 或 Future对象
+# 用asynico.wait函数等待协程完成
 asyncio.run(asyncio.wait(tasks)) # 等待所有协程对象完成
 

04 多进程,多线程,协程/py_process/09 协程/5_await关键字.py

@@ -8,7 +8,7 @@ async def work():
 
 # 调用协程的闭包
 async def do_coro():
- ret = await work() # 等待协程对象, 并获取协程的返回值
+ ret = await work() # 等待协程对象, 并获取协程的返回值, 如果当前任务是一个耗时任务则将会阻塞
  print("获得协程的返回值:", ret)
 
 

04 多进程,多线程,协程/py_process/09 协程/6_协程的嵌套.py

@@ -4,21 +4,30 @@
 # 协程的嵌套就是用一个协程函数包含其他协程函数, 可以理解为一个闭包
 
 
-async def work():
- print(f"协程{work.__name__}启动...")
- await asyncio.sleep(2)
- print(f"协程{work.__name__}完成...")
- return f"返回值{work.__hash__()}"
+WORKTIME = 4
+
+
+async def work(id):
+ print(f"协程{work.__name__}{id}启动...")
+ await asyncio.sleep(WORKTIME)
+ print(f"协程{work.__name__}{id}完成...")
+ return f"返回值哈希值{work.__hash__()}"
 
 
 async def main(*args):
+ count = 1
  for fun in args:
- print("将执行协程函数:", fun.__name__)
- ret = await fun()
+ print(f"将执行协程函数{count}:", fun.__name__)
+ ret = await fun(count) # 等待协程对象
  print("当前的返回值为:", ret)
+ count += 1
 
 
 if __name__ == "__main__":
 
- asyncio.run(main((work(), work())))
+ asyncio.run(main(work, work))
+
+
 
+# 以上程序忽略了await在处理有返回值函数的时候, 会一直阻塞直到拿到函数的返回值
+# 所以以上程序实际上是一个同步任务, 而不是异步的

04 多进程,多线程,协程/py_process/09 协程/7_Task对象.py

@@ -0,0 +1,31 @@
+import asyncio
+
+
+# 来自于文件 6_协程的嵌套.py 中的代码
+# 其中因为执行await便将协程对象提交给事件循环, 并一直等待其返回值, 所以, 原代码是顺序执行的
+# 现在使用Task对象, 将任务变为异步执行
+
+WORKTIME = 4
+
+
+async def work(id):
+ print(f"协程{work.__name__}{id}启动...")
+ await asyncio.sleep(WORKTIME)
+ print(f"协程{work.__name__}{id}完成...")
+ return f"返回值哈希值{work.__hash__()}"
+
+
+async def main(*args):
+ task1 = asyncio.create_task(args[0](1))
+ task2 = asyncio.create_task(args[1](2))
+
+ ret1 = await task1 # task不是耗时任务, 将不会阻塞等待返回值
+ ret2 = await task2
+
+ print(ret1)
+ print(ret2)
+
+
+if __name__ == "__main__":
+ 
+ asyncio.run(main(work, work))

04 多进程,多线程,协程/py_process/09 协程/8_多协程并发.py

@@ -0,0 +1,50 @@
+import asyncio
+
+
+async def coro_work(val):
+ if not isinstance(val, int):
+ raise ValueError("所给参数不为整数.")
+ print(f"{coro_work.__name__}{val}将执行: {val}s.")
+ await asyncio.sleep(val)
+ return "已经执行{}s".format(val) 
+
+
+# 方式1
+# 多协程并发, 使用await asyncio.wait(协程对象列表)的方式
+async def main1():
+ # 创建10个任务并将10个任务提交到事件循环
+ tasks = [asyncio.create_task(coro_work(i)) for i in range(1, 11)]
+
+ # asyncio.wait返回两个值, 第一个为Task对象的返回, 第二个为Task对象的执行的状态
+ # asyncio.wait返回的任务返回值是没有顺序的
+ # 使用await asyncio.wait将不会触发await等待返回值而阻塞程序
+ done, pending = await asyncio.wait(tasks)
+
+ # print("任务执行的状态:\n", pending)
+ # print("任务执行完毕后:\n", done)
+
+ # 获取任务执行的返回结果
+ print("获得执行的结果.")
+ for ret in done:
+ print(ret.result())
+
+
+# 方式2
+# 多协程并发, 使用await asyncio.gather(协程对象1, 协程对象2, ...)的方式
+async def main2():
+ # 创建10个任务并将10个任务提交到事件循环
+ tasks = [asyncio.create_task(coro_work(i)) for i in range(1, 11)]
+
+ # asyncio.gather用来收集所有已完成的任务的返回值, 并且获取到的任务的返回值是有顺序的
+ # asyncio.gather返回所有协程对象返回结果的一个列表
+ rets = await asyncio.gather(*tasks)
+
+ # print("任务执行完毕后:\n", ret)
+
+ # 获取任务执行的返回结果
+ print("获得执行的结果.")
+ for ret in rets:
+ print(ret)
+
+
+asyncio.run(main2())