Python并发编程基础 №⑦ 协程、gevent模块

协程

1.引入

进程 启动多个进程 
进程之间是由操作系统负责调用线程 启动多个线程 
真正被CPU执行的最小单位实际是线程 
开启一个线程 
创建一个线程 寄存器 堆栈
 关闭一个线程

2.简介
协程本质上是一个线程能够在多个任务之间切换来节省一些IO时间协程中任务之间的切换也消耗时间,
但是开销要远远小于进程线程之间的切换

3.用生成器的例子，来描述协程原理

def consume():
    """
    特殊生成器，不是返回值，而是要传递值给他
    :return: None
    """
    while True:
        n = yield
        print('消费了数据：', n)


def produce():
    c = consume()
    next(c)  # 无此句报错:TypeError: can't send non-None value to a just-started generator
    for i in range(10):
        print('生成了数据：',i)
        c.send(i)


produce()

4.真正的协程模块就是使用greenlet完成的切换

from greenlet import greenlet


def sing():
    print('...begin to sing... ')
    g2.switch()
    print('...end to sing... ')
    g2.switch()


def dance():
    print('---start to dance ---')
    g1.switch()
    print('---stop  dancing ---')


g1 = greenlet(sing)
g2 = greenlet(dance)

g1.switch()

5.协程模块 gevent 要用pop导入：windows下：cmd输入 pop3 install gevent 建议同时开启pycharm，否则可能安装失败！

from gevent import monkey
monkey.patch_all()
import gevent
import time
import threading

def sing():
    print('...begin to sing... ', threading.current_thread().getName())  # DummyThread-1 傀儡线程-1 （假的线程）
    time.sleep(1)
    print('...end to sing... ')


def dance():
    print('---start to dance ---',  threading.current_thread())  # <_DummyThread(DummyThread-2, started daemon 1390457303880)>
    time.sleep(1)
    print('---stop  dancing ---',  threading.get_ident())  # 1390457303880

g1 = gevent.spawn(sing)
g2 = gevent.spawn(dance)
gevent.joinall((g1, g2))  # 没monkey.patch_all()，就识别不了阻塞（time的），就无法切换协程

进程和线程的任务切换,由操作系统完成
协程任务之间的切换由程序(代码)完成,只有遇到协程模块能识别的IO操作的时候,程序才会进行任务切换,实现并发的效果。

6.同步 和 异步

from gevent import monkey;monkey.patch_all()
import time
import gevent


def task(n):
    time.sleep(1)
    print(n)


def sync():
    '''
    同步生成：隔一秒打印一个数字
    :return:
    '''
    for i in range(10):
        task(i)


def async():
    """
    异步生成：所有数字一起打印出来
    :return:
    """
    g_lst = []
    for i in range(10):
        g = gevent.spawn(task, i)
        g_lst.append(g)
    gevent.joinall(g_lst)

# sync()
async()

　7.小结：

协程 : 能够在一个线程中实现并发效果的概念
       能够规避一些任务中的IO操作
       在任务的执行过程中,检测到IO就切换到其他任务

多线程 被弱化了
协程 在一个线程上 提高CPU 的利用率
协程相比于多线程的优势 切换的效率更快

8.协程应用一，网络爬虫升级版

from gevent import monkey
monkey.patch_all()  # ;作用是将多行显示在一行 ，monkey的作用是让gevent识别下面引入包中的io事件
import gevent
from urllib.request import urlopen


# 启动5个协程并发去抓取5个网站首页的内容，并打印其长度！
# 作用：在等待io的时间，去完成抓取其他网站首页的内容的任务，提高效率，节约时间成本！


def get(url):
    """
    获取url地址对应网页的内容
    :param url: 地址
    :return: None
    """
    response = urlopen(url)
    content = response.read().decode('utf-8')
    print(url, len(content))


url_list = (
 'http://www.sohu.com', 'http://www.baidu.com', 'http://www.cnblogs.com',
 'http://sports.sina.com.cn', 'http://jd.com')

g_list = []
for url in url_list:
    g = gevent.spawn(get, url)
    g_list.append(g)

gevent.joinall(g_list)

9.协程应用二，socket聊天

# 服务器端
from gevent import monkey;monkey.patch_all()
import gevent
import socket

def talk(conn):
    msg = conn.recv(1024).decode('utf-8')
    print(msg)
    ipt = input('>>>').encode('utf-8')
    conn.send(ipt)
    conn.close()

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

try:
    while 1:
        conn, addr = sk.accept()
        # talk(conn)
        gevent.spawn(talk, conn)
except:
    sk.close()


#客户端
import socket

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

sk.send(b'hello')
msg = sk.recv(1024).decode('utf-8')
print(msg)