天天看点

协程(多任务)1. 什么是协程?2.协程-yield3. 协程-grennlet4. 协程-gevent5.并发下载器6.进程、线程、协程对比

协程(多任务)

  • 1. 什么是协程?
  • 2.协程-yield
  • 3. 协程-grennlet
  • 4. 协程-gevent
  • 5.并发下载器
  • 6.进程、线程、协程对比

1. 什么是协程?

协程,又叫微线程,纤程。是python中另外一种实现多任务的方式。

2.协程-yield

import time

def work1():
    while True:
        print("----work1---")
        yield
        time.sleep(0.5)

def work2():
    while True:
        print("----work2---")
        yield
        time.sleep(0.5)

def main():
    w1 = work1()
    w2 = work2()
    while True:
        next(w1)
        next(w2)

if __name__ == "__main__":
    main()
           

运行结果:

----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
...省略...
           

3. 协程-grennlet

更好使用协程完成多任务,切换任务变的更加简单

  1. 安装方式
    sudo pip3 install greenlet
               
  2. demo实现
    from greenlet import greenlet
    import time
    
    def test1():
        while True:
            print("---A--")
            gr2.switch()
            time.sleep(0.5)
    
    def test2():
        while True:
            print("---B--")
            gr1.switch()
            time.sleep(0.5)
    
    gr1 = greenlet(test1)
    gr2 = greenlet(test2)
    
    #切换到gr1中运行
    gr1.switch()
    
    # 协程与进程、线程的不同
    # 1. 进程、线程 创建完之后,到底是哪个进程、线程执行 不确定,这要让操作系统来进行计算(调度算法,例如优先级调度)
    # 2. 协程是可以人为来控制的
               
    运行结果:
    ---A--
    ---B--
    ---A--
    ---B--
    ---A--
    ---B--
    ---A--
    ---B--
    ...省略...
               

4. 协程-gevent

自动切换协程

  1. 安装方式
    pip3 install gevent
               
  2. gevent的使用
    import gevent
    
    
    def f1(n):
        for i in range(n):
            print("-----f1-----", i)
    
    
    def f2(n):
        for i in range(n):
            print("-----f2-----", i)
    
    
    def f3(n):
        for i in range(n):
            print("-----f3-----", i)
    
    
    g1 = gevent.spawn(f1, 5)
    g2 = gevent.spawn(f2, 5)
    g3 = gevent.spawn(f3, 5)
    g1.join()  # join会等待g1标识的那个任务执行完毕之后 对其进行清理工作,其实这就是一个 耗时操作
    g2.join()
    g3.join()
               
    运行结果:
    -----f1----- 0
    -----f1----- 1
    -----f1----- 2
    -----f1----- 3
    -----f1----- 4
    -----f2----- 0
    -----f2----- 1
    -----f2----- 2
    -----f2----- 3
    -----f2----- 4
    -----f3----- 0
    -----f3----- 1
    -----f3----- 2
    -----f3----- 3
    -----f3----- 4
               
    发现3个greenlet是一次运行而不是交替运行
  3. gevent切换运行
    import gevent
    
    
    def f1(n):
        for i in range(n):
            print("-----f1-----", i)
            gevent.sleep(1)
    
    
    def f2(n):
        for i in range(n):
            print("-----f2-----", i)
            gevent.sleep(1)
    
    
    def f3(n):
        for i in range(n):
            print("-----f3-----", i)
            gevent.sleep(1)
    
    
    g1 = gevent.spawn(f1, 5)
    g2 = gevent.spawn(f2, 5)
    g3 = gevent.spawn(f3, 5)
    g1.join()  # join会等待g1标识的那个任务执行完毕之后 对其进行清理工作,其实这就是一个 耗时操作
    g2.join()
    g3.join()
    
    # 使用gevent来实现多任务的时候,有一个很特殊的地方
    # 它可以自行切换协程指定的任务,而且切换的前提是:当一个任务用到耗时操作(例如延时),它就会把这个时间拿出来去做另外的任务
    # 这样做最终实现了多任务 而且自动切换
               
    运行结果:
    -----f1----- 0
    -----f2----- 0
    -----f3----- 0
    -----f1----- 1
    -----f2----- 1
    -----f3----- 1
    -----f1----- 2
    -----f2----- 2
    -----f3----- 2
    -----f1----- 3
    -----f2----- 3
    -----f3----- 3
    -----f1----- 4
    -----f2----- 4
    -----f3----- 4
               
    想让gevent自动切换任务,就需要有耗时操作,只要有耗时操作,gevent就是自动进行切换
  4. 给程序打补丁
    import gevent
    import time
    
    
    def f1(n):
        for i in range(n):
            print("-----f1-----", i)
            # gevent.sleep(1)
            time.sleep(1)
    
    
    def f2(n):
        for i in range(n):
            print("-----f2-----", i)
            # gevent.sleep(1)
            time.sleep(1)
    
    def f3(n):
        for i in range(n):
            print("-----f3-----", i)
            # gevent.sleep(1)
            time.sleep(1)
    
    
    g1 = gevent.spawn(f1, 5)
    g2 = gevent.spawn(f2, 5)
    g3 = gevent.spawn(f3, 5)
    g1.join()  # join会等待g1标识的那个任务执行完毕之后 对其进行清理工作,其实这就是一个 耗时操作
    g2.join()
    g3.join()
    
    # 使用gevent来实现多任务的时候,有一个很特殊的地方
    # 它可以自行切换协程指定的任务,而且切换的前提是:当一个任务用到耗时操作(例如延时),它就会把这个时间拿出来去做另外的任务
    # 这样做最终实现了多任务 而且自动切换
               
  5. 使用joinall
    import gevent
    import random
    import time
    from gevent import monkey
    
    
    monkey.patch_all()
    
    
    def coroutine_work(coroutine_name):
        for i in range(10):
            print(coroutine_name, i)
            time.sleep(random.random())
    
    
    def coroutine_work2(coroutine_name):
        for i in range(10):
            print(coroutine_name, i)
            time.sleep(random.random())
    
    
    gevent.joinall([
            gevent.spawn(coroutine_work, "work1"),
            gevent.spawn(coroutine_work2, "work2")
    ])
               
    运行结果:
    work1 0
    work2 0
    work2 1
    work1 1
    work2 2
    work1 2
    work2 3
    work1 3
    work2 4
    work1 4
    work2 5
    work1 5
    work2 6
    work1 6
    work2 7
    work1 7
    work2 8
    work1 8
    work2 9
    work1 9
               
    为了更简单的使用gevent实现相似的多任务,可以使用gevent.joinall,只要将得到的协程对象放到里面即可

5.并发下载器

使用程序下载

import urllib.request

# 1. 准备好要下载的url
image_url = "http://czxy.com/Attached/image/20171204/20171204212606_55840.png"

# 2. 打开这个url
image = urllib.request.urlopen(image_url)

# 3. 获取url标记的文件数据 
data = image.read()

# 4. 将读取到的数据存到到文件中,注意从下载下来的数据是二进制,因此操作时需要用"wb"
with open("图片.jpg", "wb") as f:
    f.write(data)

print("下载完毕")
           

并发下载(多个视频下载)

from gevent import monkey
import gevent
import urllib.request
import ssl

monkey.patch_all()

ssl._create_default_https_context = ssl._create_unverified_context


def my_downLoad(file_name, url):
    print('GET: %s' % url)
    resp = urllib.request.urlopen(url)
    data = resp.read()

    with open(file_name, "wb") as f:
        f.write(data)

    print('%d bytes received from %s.' % (len(data), url))


gevent.joinall([
    gevent.spawn(my_downLoad, "1.mp4", 'http://video.howdoit.cn/Atlas,%20The%20Next%20Generation.mp4'),
    gevent.spawn(my_downLoad, "2.mp4", 'from gevent import monkey
import gevent
import urllib.request
import ssl

monkey.patch_all()

ssl._create_default_https_context = ssl._create_unverified_context


def my_downLoad(file_name, url):
    print('GET: %s' % url)
    resp = urllib.request.urlopen(url)
    data = resp.read()

    with open(file_name, "wb") as f:
        f.write(data)

    print('%d bytes received from %s.' % (len(data), url))


gevent.joinall([
    gevent.spawn(my_downLoad, "1.mp4", 'http://video.howdoit.cn/Atlas,%20The%20Next%20Generation.mp4'),
    gevent.spawn(my_downLoad, "2.mp4", 'http://video.howdoit.cn/%E8%83%BD%E5%8A%9B%E8%A1%A5%E5%85%85Xschool%E5%88%9B%E5%A7%8B%E4%BA%BAAngel%20Lin%EF%BC%9A%E6%89%93%E7%A0%B4%E8%AF%BE%E5%A0%82%E7%9A%84%E5%A2%99%EF%BC%8C%E5%9F%B9%E5%85%BB%E5%9B%BD%E9%99%85%E5%8C%96%E7%9A%84%E5%B0%91%E5%B9%B4.mp4')
])

           

上面的代码,完成了下载2个视频

可以将url换为自己需要下载视频、音乐、图片等网址,重新执行即可完成下载

6.进程、线程、协程对比

  1. 进程是资源分配的单位
  2. 线程是操作系统调度的单位
  3. 进程切换需要的资源很最大,效率很低
  4. 线程切换需要的资源一般,效率一般(当然了在不考虑GIL的情况下)
  5. 协程切换任务资源很小,效率高
  6. 多进程、多线程根据cpu核数不一样可能是并行的,但是协程是在一个线程中 所以是并发