Day 29 协程

                                              协程                                   

# 协程
    # 1.协程的本质 就是一条线程分成多份，每一份去执行一段代码
    #   多段代码能够在一条线程之间来回切换
    # 2.如果能够在一段代码执行遇到阻塞的过程中切换到另一段可以执行的代码上
    #   就相当于完成利用协程完成了更加充分利用线程的目的
    # 3.协程利用切换来规避IO操作带来的好处
        # 1.一条线程能够执行多个任务了
        # 2.减少了一条线程的阻塞，帮助线程在操作系统调度的时候多抢占CPU
        # 3.协程由于操作系统不可见，所以协程的切换不是由操作系统控制的
        #   是由我们程序员控制的
        #   协程是用户级的
        # 4.协程之间永远数据安全 —— 因为协程的本质是一条线程

需要强调的是：
#1. python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）
#2. 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）

对比操作系统控制线程的切换，用户在单线程内控制协程的切换

优点如下：

#1. 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
#2. 单线程内就可以实现并发的效果，最大限度地利用cpu

缺点如下：

#1. 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程内开启多个线程，每个线程内开启协程
#2. 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

总结协程特点：

  1. 必须在只有一个单线程里实现并发
  2. 修改共享数据不需加锁
  3. 用户程序里自己保存多个控制流的上下文栈
  4. 附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））


                            Greenlet模块                                      




greenlet只是提供了一种比generator更加便捷的切换方式，当切到一个任务执行时如果遇到io，那就原地阻塞，仍然是没有解决遇到IO自动切换来提升效率的问题。




单线程里的这20个任务的代码通常会既有计算操作又有阻塞操作，我们完全可以在执行任务1时遇到阻塞，就利用阻塞的时间去执行任务2。。。。如此，才能提高效率，


这就用到了Gevent模块。








#顺序执行
import time
def f1():
    res=1
    for i in range(100000000):
        res+=i

def f2():
    res=1
    for i in range(100000000):
        res*=i

start=time.time()
f1()
f2()
stop=time.time()
print('run time is %s' %(stop-start)) #10.985628366470337

#切换
from greenlet import greenlet
import time
def f1():
    res=1
    for i in range(100000000):
        res+=i
        g2.switch()

def f2():
    res=1
    for i in range(100000000):
        res*=i
        g1.switch()

start=time.time()
g1=greenlet(f1)
g2=greenlet(f2)
g1.switch()
stop=time.time()
print('run time is %s' %(stop-start)) # 52.763017892837524



效率测试




 


                             Gevent模块                                       








g1=gevent.spawn(func,1,,2,3,x=4,y=5)创建一个协程对象g1，spawn括号内第一个参数是函数名，如eat，后面可以有多个参数，可以是位置实参或关键字实参，都是传给函数eat的

g2=gevent.spawn(func2)

g1.join() #等待g1结束

g2.join() #等待g2结束

#或者上述两步合作一步：gevent.joinall([g1,g2])

g1.value#拿到func1的返回值



用法介绍






from gevent import monkey
monkey.patch_all()   # 加了这句话，一些阻塞才能被识别
import time
import gevent

def eat():
    print('eat1')
    time.sleep(1)
    print('eat2')

def sleep():
    print('sleep1')
    time.sleep(1)
    print('sleep2')

g1 = gevent.spawn(eat)
g2 = gevent.spawn(sleep)
g1.join()
g2.join()



代码示例


我们可以用threading.current_thread().getName()来查看每个g1和g2，查看的结果为DummyThread-n，即假线程








from gevent import monkey;monkey.patch_all()
import threading
import gevent
import time
def eat():
    print(threading.current_thread().getName())
    print('eat food 1')
    time.sleep(2)
    print('eat food 2')

def play():
    print(threading.current_thread().getName())
    print('play 1')
    time.sleep(1)
    print('play 2')

g1=gevent.spawn(eat)
g2=gevent.spawn(play)
gevent.joinall([g1,g2])
print('主')
复制代码
 

Gevent之同步与异步
复制代码
from gevent import spawn,joinall,monkey;monkey.patch_all()

import time
def task(pid):
    """
    Some non-deterministic task
    """
    time.sleep(0.5)
    print('Task %s done' % pid)


def synchronous():  # 同步
    for i in range(10):
        task(i)

def asynchronous(): # 异步
    g_l=[spawn(task,i) for i in range(10)]
    joinall(g_l)
    print('DONE')
    
if __name__ == '__main__':
    print('Synchronous:')
    synchronous()
    print('Asynchronous:')
    asynchronous()
#  上面程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。
#  初始化的greenlet列表存放在数组threads中，此数组被传给gevent.joinall 函数，
#  后者阻塞当前流程，并执行所有给定的greenlet任务。执行流程只会在 所有greenlet执行完后才会继续向下走。



View Code




                           Gevent之应用举例一                            






from gevent import monkey
monkey.patch_all()
import time
from urllib import request
import gevent

def func1(name, url):
    ret = request.urlopen(url)
    with open(name, 'wb') as f:
        f.write(ret.read())

start = time.time()
url_list = [
    ('百度','https://www.baidu.com/'),
    ('豆瓣','https://www.douban.com/'),
    ('去哪儿','https://www.qunar.com/?ex_track=auto_4e0d874a')
]
for url_item in url_list:
    func1(*url_item)
end = time.time()
print(end-start)


def func2(name, url):
    ret = request.urlopen(url)
    with open(name, 'wb') as f:
        f.write(ret.read())

start = time.time()
url_list = [
    ('百度','https://www.baidu.com/'),
    ('豆瓣','https://www.douban.com/'),
    ('去哪儿','https://www.qunar.com/?ex_track=auto_4e0d874a')
]

lst = []
for url_item in url_list:
    g = gevent.spawn(func2,*url_item)
    lst.append(g)
gevent.joinall(lst)
end = time.time()
print(end-start)



爬虫


                                Gevent之应用举例二                                     






from gevent import monkey
monkey.patch_all()
import socket
import gevent

def func(conn):
    while True:
        msg = conn.recv(1024).decode()
        conn.send(msg.upper().encode())

sk = socket.socket()
sk.bind(('127.0.0.1',9000))
sk.listen()

while True:
    conn,addr = sk.accept()
    gevent.spawn(func, conn)



server






import socket

sk = socket.socket()
sk.connect(('127.0.0.1',9000))


while True:
    sk.send(b'hello')
    msg = sk.recv(1024).decode()
    print(msg)



client


 


 


 







		

		
posted @ 
2019-01-31 23:53 
addit 
Views(88) 
Comments(0) 
 
收藏 
举报