Python

协程：是单线程下的并发，又称微线程，纤程。英文名Coroutine。协程是一种用户态的轻量级线程，即协程是由用户程序自己控制调度的。
并发的本质：切换+保存状态
在操作系统中
- 进程：是资源分配的最小单位
- 线程：是CPU调度的最小单位
- 协程：是单线程内实现并发切换执行任务的
使用yield也可以实现在一个主线程中切换执行

# 生成器 yield
def func1():
    print(1)
    yield
    print(3)
    yield

def func2():
    g = func1()   # 生成器函数在被调用时不会立即执行，除非next(g)触发才可以
    next(g)       # 开始执行func1()函数，但是遇到yield就会停止
    print(2)
    next(g)
    print(4)

func2()

# 结果呈现
1
2
3
4

def consumer():    # 消费者模型
    while True:
        n = yield     # yield接收g.send()的结果，然后赋值给n
        print("消费了包子 %s" % n)

def producer():   # 生产者模型
    g = consumer()    # 调用生成器函数，并不会理解执行生成器函数内部的代码（除非next()进行触发）
    next(g)   # 开始执行生成器函数
    for i in range(10):
        print("生产了包子 %s" % i)
        g.send(i) # send()给生成器函数yield处接收

producer()

# 结果呈现
生产了包子 0
消费了包子 0
生产了包子 1
消费了包子 1
生产了包子 2
消费了包子 2
生产了包子 3
消费了包子 3
生产了包子 4
消费了包子 4
生产了包子 5
消费了包子 5
生产了包子 6
消费了包子 6
生产了包子 7
消费了包子 7
生产了包子 8
消费了包子 8
生产了包子 9
消费了包子 9

在yield切换中，在任务一遇到io情况下，切到任务二去执行，这样就可以利用任务一阻塞的时间完成任务二的计算，效率的提升就在于此。
需要强调的是：
- 1 python的线程属于内核级别的，即由操作系统控制调度（如单线程遇到io或执行时间过长就会被迫交出cpu执行权限，切换其他线程运行）
- 2 单线程内开启协程，一旦遇到io，就会从应用程序级别（而非操作系统）控制切换，以此来提升效率（！！！非io操作的切换与效率无关）
对比操作系统控制线程的切换，用户在单线程内控制协程的切换
- 优点：
  - 1 协程的切换开销更小，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级
  - 2 单线程内就可以实现并发的效果，最大限度地利用CPU
- 缺点：
  - 1 协程的本质是单线程下，无法利用多核，可以是一个程序开启多个进程，每个进程开启多个线程，每个线程内开启协程
  - 2 协程指的是单个线程，因而一旦协程出现阻塞，将会阻塞整个线程
总结协程特点
- 1 必须在只有要给单线程里实现并发
- 2 修改共享数据不需要加锁
- 3 用户程序里自己保持多个控制的上下文栈
- 4 附加：一个协程遇到IO操作自动切换到其它协程（如何实现检测IO，yield、greenlet都无法实现，就用到了gevent模块（select机制））

2，greenlet模块

2.1 greenlet 实现同一线程内切换

import time
from greenlet import greenlet   # 在单线程中切换状态的模块
def eat1():
    print("吃鸡腿")
    g2.switch()     # 切换执行eat2
    time.sleep(5)         # greenlet进行切换时，并不会规避掉IO时间（也就是切换回来时还是需要等待2秒在执行）
    print("吃鸡翅")
    g2.switch()     # 切换执行eat2
def eat2():
    print("吃饺子")
    g1.switch()     # 切换执行eat1
    time.sleep(3)         # greenlet进行切换时，并不会规避掉IO时间（也就是切换回来时还是需要等待2秒在执行）
    print("白切鸡")

g1 = greenlet(eat1)
g2 = greenlet(eat2)
g1.switch()    # 切换执行eat1

# 结果呈现
吃鸡腿
吃饺子
吃鸡翅
白切鸡

如果在同一个程序有IO的情况下，才切换会让效率提高很多，但是yield greenlet均不会在切换时规避掉IO时间

2.2 greenlet 实现效率对比

#顺序执行
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

3，gevent模块

gevent 就是当遇到gevent.sleep() IO 时会自动切换；

# gevent 内部封装了greenlet模块
import gevent
def eat(name):
    print('%s eat 1' %name)
    gevent.sleep(2)        # gevent可以在gevevt.sleep()自己认识的IO操作切换
    print('%s eat 2' %name)

def play(name):
    print('%s play 1' %name)
    gevent.sleep(1)
    print('%s play 2' %name)


g1=gevent.spawn(eat,'egon')
g2=gevent.spawn(play,name='egon')
# g1.join()
# g2.join()
gevent.joinall([g1,g2])    # 相当于上面的g1.join()  g2.join()

# 结果呈现
egon eat 1
egon play 1
egon play 2
egon eat 2

gevent()对普通的IO （比如time模块的sleep,socket 以及urllib request等网络请求）是无法切换的：

import gevent,time
def eat(name):
    print('%s eat 1' %name)
    time.sleep(2)
    print('%s eat 2' %name)

def play(name):
    print('%s play 1' %name)
    time.sleep(1)
    print('%s play 2' %name)


g1=gevent.spawn(eat,'egon')
g2=gevent.spawn(play,name='egon')
gevent.joinall([g1,g2])

# 结果呈现
egon eat 1
egon eat 2
egon play 1
egon play 2

上例gevent.sleep(2)模拟的是gevent可以识别的io阻塞,而time.sleep(2)或其他的阻塞,gevent是不能直接识别的需要用下面一行代码,打补丁,就可以识别了
from gevent import monkey;monkey.patch_all() 必须放到被打补丁者的前面，如time，socket模块之前
我们可以用 threading.current_thread().getName() 来查看每个g1和g2，查看的结果为DummyThread-n，即假线程

from gevent import monkey;monkey.patch_all()    # 加上这句话，gevent遇到其他模块（time,socket等IO操作）的IO 需要等待时 就会切换协程
from threading import current_thread
import gevent,time
def func1():
    print(current_thread().name)    # 打印当前线程名（其实协程并不是线程，多个协程是在同一个线程内完成的）
    print(123)
    time.sleep(1)
    print(456)

def func2():
    print(current_thread().name)
    print(789)
    time.sleep(1)
    print(101112)

g1 = gevent.spawn(func1)    # 遇见它认识的io会自动切换的模块
g2 = gevent.spawn(func2)
# g1.join()
# g2.join()
gevent.joinall([g1,g2])

# 结果呈现
DummyThread-1
123
DummyThread-2
789
456
101112

3.1 Gevent之同步与异步

测试有IO操作时，使用多个协程与开单线程单步执行多个任务执行效率的对比

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

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

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

def async_func():   # 异步
    g_lst = []
    for i in range(10):
        g_lst.append(gevent.spawn(task,i))    # 发起协程任务，传参数
    gevent.joinall(g_lst)

start = time.time()
sync_fucn()
print(time.time() - start)

start = time.time()
async_func()
print(time.time() - start)

# 结果呈现
0
1
2
3
4
5
6
7
8
9
10.011728048324585
0
1
2
3
4
5
6
7
8
9
1.0025279521942139

3.2 开多个协程去爬取多个网页与单线程单步执行爬取网页的效率对比

# 爬去网页信息的例子
from gevent import monkey;monkey.patch_all()
import gevent,requests,time

# 协程函数发起10个网页的爬取任务
def get_url(url):
    res = requests.get(url)
    print(url,res.status_code,len(res.text))    # 返回爬取网页的信息（requests.get(url).text----获取网页源代码； requests.get(url).status_code----获取网页状态码）

url_lst = [
    "http://www.sohu.com",
    "http://www.baidu.com",
    "http://www.qq.com",
    "http://www.python.org",
    "http://www.cnblogs.com",
    "http://www.mi.com",
    "http://www.apache.org"
]

g_lst = []
start = time.time()
for url in url_lst:
    g = gevent.spawn(get_url,url)
    g_lst.append(g)
gevent.joinall(g_lst)
print(time.time() - start)

start = time.time()
for url in url_lst:
    get_url(url)
print(time.time() - start)

# 结果呈现
http://www.baidu.com 200 2381
http://www.sohu.com 200 178923
http://www.qq.com 200 205793
http://www.mi.com 200 312788
http://www.cnblogs.com 200 41063
http://www.apache.org 200 62019
http://www.python.org 200 49235
1.198430061340332
http://www.sohu.com 200 178923
http://www.baidu.com 200 2381
http://www.qq.com 200 205793
http://www.python.org 200 49235
http://www.cnblogs.com 200 41043
http://www.mi.com 200 312788
http://www.apache.org 200 62019
2.1779263019561768

协程在响应一个网页时，有网络延时，它就可能利用这个时间去打开其他网页了，也就是时间复用，有可能利用第一个网页等待时间，把剩下所有网页的请求都发出去了；
同步单步执行时，每执行一个网页就会等待网络延时，串行的；而协程就是在发送一个网页时，不等，因为它直到有网络延时，所以直接执行下一个任务；

3.3 使用协程完成server端和client端的通信

测试连通性

# server
import socket

sk = socket.socket()
sk.bind(("127.0.0.1",8080))
sk.listen()

conn,addr = sk.accept()
ret = conn.recv(1024).decode("utf-8")
print(ret)
conn.send(ret.upper().encode("utf-8"))
conn.close()
sk.close()

# client
import socket
sk = socket.socket()
sk.connect(("127.0.0.1",8080))
sk.send(b"hi")
ret = sk.recv(1024).decode("utf-8")
print(ret)
sk.close()

客户端并发连接服务端

# server
from gevent import monkey;monkey.patch_all()
import socket,gevent

def talk(conn):
    while True:
        ret = conn.recv(1024).decode("utf-8")
        print(ret)
        conn.send(ret.upper().encode("utf-8"))
    conn.close()

sk = socket.socket()
sk.bind(("127.0.0.1",8080))
sk.listen()

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

# client
from gevent import monkey;monkey.patch_all()
import socket,gevent,time,threading

def my_client():
    sk = socket.socket()
    sk.connect(("127.0.0.1",8080))
    while True:
        sk.send(b"hi")
        ret = sk.recv(1024).decode("utf-8")
        print(ret)
        time.sleep(1)
    sk.close()
for i in range(500):
    threading.Thread(target=my_client).start()

(cpucount + 1 ) * cpucount * 5 * 500并发 == 50000
转自：https://www.cnblogs.com/Eva-J/articles/8324673.html

Python

目录

1，协程介绍

2，greenlet模块

2.1 greenlet 实现同一线程内切换

2.2 greenlet 实现效率对比

3，gevent模块

3.1 Gevent之同步与异步

3.2 开多个协程去爬取多个网页与单线程单步执行爬取网页的效率对比

3.3 使用协程完成server端和client端的通信

Python

目录

1，协程介绍

2，greenlet模块

2.1 greenlet 实现同一线程内切换

2.2 greenlet 实现 效率对比

3，gevent模块

3.1 Gevent之同步与异步

3.2 开多个协程去爬取多个网页与单线程单步执行爬取网页的效率对比

3.3 使用协程完成server端和client端的通信

2.2 greenlet 实现效率对比