python并发之协程_python并发编程之协程

一，协程

协程：是单线程下的并发，又称微线程，纤程。协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。

1，python的线程属于内核级别的，即有操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出执行权限，切换其他线程运行）

2，单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，一次来提升效率（！！！非io操作的切换与效率无关）

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

优点：写成的切换开销小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级

单线程内就可以实现并发的效果，最大限度利用CPU

缺点：协程的本质是单线程下，无法利用多核，可以是一个程序开启多个线程，每个进程内开启多个线程，吗，每个线程内开启协程

协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程

总结协程特点

1，必须在只有一个单线程里实现并发

2，修改共享数据不许加锁

3，用户程序里自己保存多个控制流的上下文栈

4，一个程序遇到IO操作自动切换到其他协程（如何实现检测IO，yield，greenlet都无法实现，就用到了gevent模块（select机制））

二，Greenelt模块 （安装模块的命令为：pip3 install greenlet 在cmd命令下安装）

fromgreenlet import greenlet

import time

def eat(name): #定义一个带参数的（吃）函数

print('%s eat 1'%name)

time.sleep(10)

g2.switch('egon') #遇到阻塞就切换

print('%s eat 2' %name)

g2.switch()

def play(name): #定义玩函数

print('%s play 1' %name)

g1.switch() #

print('%s play 2' %name)

g1=greenlet(eat) #实例化对象

g2=greenlet(play) #实例化对象

g1.switch('egon') #可以在第一次的switch下传入参数，以后都不再需要

单纯的切换（在没有io的情况下或者没有重复开辟内存空间的操作），反而会降低程序的执行速度

三，Gevent

Gevent：是一个第三方库，可轻松通过Greenlet实现同步或异步编编程

用法：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.jionall([g1,g2])

fromgevent import monkey;monkey.patch_all()

import gevent

import time

def eat(name):

print('%s eat 1' %name)

time.sleep(2)

print('%s eat 2' %name)return 'eat'def paly(name):

print('%s paly 1' %name)

time.sleep(1)

print('%s paly 2' %name)return 'paly'start=time.time()

g1=gevent.spawn(eat,'egon')

g2=gevent.spawn(paly,'egon')

# g1.join()

# g2.join()

gevent.joinall([g1,g2])

print('主',(time.time()-start))

print(g1.value)

print(g2.value)

四，Gevent之同步与异步

fromgevent import spawn,joinall,monkey;monkey.patch_all()

import time

def task(pid):''' Some non-deterministtic tack''' time.sleep(0.5)

print('Tack %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)if __name__ == '__main__':

print('Synchronous')

synchronous()

print('Asynchronous:')

asynchronous()'''上面程序的重要部分是将task函数封装到Greenlet内部线程的gevent.spawn。 初始化的greenlet列

表存放在数组threads中，此数组被传给gevent.joinall 函数，后者阻塞当前流程，并执行所有给定

的greenlet。执行流程只会在 所有greenlet执行完后才会继续向下走。'''

五，Gevent之应用

协程应用：爬虫

fromgevent import monkey;monkey.patch_all()

import gevent

import requests

import time

def get_page(url): #定义函数

print('GET: %s' %url) #

response=requests.get(url) #请求获得的网址if response.status_code==200:

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

start_time=time.time() #开始时间

#要爬取的网址

gevent.joinall([

gevent.spawn(get_page,'http://www.python.org/'),

gevent.spawn(get_page,'https://www.yahoo.com/'),

gevent.spawn(get_page,'https://github.com/'),

])

stop_time=time.time() #结束时间

print('run time is %s' %(stop_time-start_time)) #爬取网址的时间