协程 （协程实现多任务）

1.协程：
    1.又称微线程，
    2.协程是python个中另外一种实现多任务的方式，比线程更小更小占用执行单元
    3.通俗理解，就是一个可以挂起，可以暂停的函数
    4.通过yield生成器就可以实现协程
2.协程实现的方式有三种
    1.通过yield生成器实现协程
    2.使用greenlet实现协程
    3.使用gevent实现协程

    1.通过yield生成器实现协程
        # import time
        #
        #
        # def work1():
        #     while True:
        #         print("---work1----")
        #         yield
        #         time.sleep(1)
        #
        # def work2():
        #     while True:
        #         print("---work2----")
        #         yield
        #         time.sleep(0.5)
        # def work3():
        #     while True:
        #         print("---work3----")
        #         yield
        #         time.sleep(0.5)
        # def work4():
        #     while True:
        #         print("---work4----")
        #         yield
        #         time.sleep(1)
        #
        # if __name__ == '__main__':
        #     #创建生成器
        #     w1 = work1()
        #     w2 = work2()
        #     w3 = work3()
        #     w4 = work4()
        #
        #     #不断的唤醒生成器
        #     while True:
        #         next(w1)
        #         next(w2)
        #         next(w3)
        #         next(w4)


    2.使用greenlet实现协程
        1.greenlet是python中的一个模块，是对yield生成器的封装，可更简便的实现协程
        2.这种方式的弊端在于当在创建对象后再去执行的话，两个不会同时进行，
        只有放在函数的中间来回切换，才能实现多任务，但如果协程多了，人为切换会很麻烦
        而且容易出错，所以有更好的方法来取代这个，那就是gevent实现协程

        # import time
        #
        # import greenlet
        #
        #
        # def work1():
        #     while True:
        #         print("---work1----")
        #         # yield
        #         gl2.switch()
        #         time.sleep(1)
        #
        # def work2():
        #     while True:
        #         print("---work2----")
        #         # yield
        #         gl1.switch()
        #         time.sleep(1)
        #
        #
        # if __name__ == '__main__':
        #     #创建greenlet对象
        #     gl1 = greenlet.greenlet(run=work1)
        #     gl2 = greenlet.greenlet(run=work2)
        #     #执行greenlet，
        #     gl1.switch()


    3.使用gevent实现协程
        1.gevent是对greenlet再一次封装
        2.他的原理是当一个greenlet遇到IO(指的是I/O输入输出操作时，比如访问网络，硬盘等)
        操作时，就自动切换到其他的greenlet，等io操作完毕后在切换回来继续执行
        3.由于io操作非常耗时，经常使进程处于等待状态，有了gevent能够自动切换，就保证有
        greenlet在运行，而不用等待

        4.注意点：
            1.在gevent中，如果使用原生函数(也就是python本身内置的函数)会出错，
            比如使用time时，只会一个一个运行

        5.gevent优化
            1.写法的优化
                创建gevent对象可以写成：
                    event.joinall([gevent.spawn(work1,1),gevent.spawn(work1,2),gevent.spawn(work1,3)])     2.给
            2.给gevent打补丁
                from gevent import monkey
                monkey.patch_all()
        """
        import gevent
        import time
        from gevent import monkey

        def work1(index):
            for i in range(3):
                print("当前任务：%s   代码块%d  当前gevent对象%s"%(index,i,str(gevent.getcurrent())))
                # gevent.sleep(1)#这个是gvent内置的函数，不是python原生函数
                time.sleep(1)#在没有打补丁的情况下，gevent是不认这个time函数的，

        if __name__ == '__main__':
            #打补丁
            monkey.patch_all()
            #创建gevent对象
            # g1 = gevent.spawn(work1,1)
            # g2 = gevent.spawn(work1,2)
            # g3 = gevent.spawn(work1,3)
            # g1 = gevent.spawn(work1,1)
            # g2 = gevent.spawn(work1,2)
            # g3 = gevent.spawn(work1,3)
            #
            # g1.join()#这里的join有开启的意思，也有阻塞的意思，当所有协程执行完毕后，主进程才执行完毕
            # g2.join()
            # g3.join()
            # print("-------")

            gevent.joinall([gevent.spawn(work1,1),gevent.spawn(work1,2),gevent.spawn(work1,3)])
            print("------")