python线程、协程

线程

创建线程对象

from threading import Thread

t = Thread()
# 功能：创建线程对象
# 参数：target 绑定线程函数
#	args 元组 给线程函数位置传参
#   kwargs 字典 给线程函数键值传参

启动线程

t.start()  # 启动线程

回收线程

t.join([timeout])  # 回收线程

示例

import threading 
from time import sleep,ctime

loops=[4,2]

def loop(nloop,nsec):
    print('start loop',nloop ,' at:',ctime())
    sleep(nsec)
    print('loop',nloop ,'done at:',ctime())

def main():
    threads=[]
    nloops = range(len(loops))
    for i in nloops:
        # 注意传参
        t = threading.Thread(target=loop,args=(i,loops[i]))
        threads.append(t)
    for in in nloops:
        threads[i].start()
    for i in nloops:
        threads[i].join()

if __name__ == '__main__':
    main()

自定义线程类

import threading 
from time import sleep,ctime

loops=[4,2]

class MyThread(threading.Thread):
    def __init__(self,func,args,name=''):
        threading.Thread.__init__(self)
        self.func = func
        self.args = args
        self.name = name
    def run(self):
        self.func(*self.args)

def loop(nloop,nsec):
    print('start loop',nloop ,' at:',ctime())
    sleep(nsec)
    print('loop',nloop ,'done at:',ctime())

def main():
    threads=[]
    nloops = range(len(loops))
    for i in nloops:
        t = MyThread(loop,(i,loops[i]),loop.__name__)
        threads.append(t)
    for in in nloops:
        threads[i].start()
    for i in nloops:
        threads[i].join()

if __name__ == '__main__':
    main()

Event 线程同步

线程之间用于交互的一个对象，这个event是一个内部的标签，线程可以等待这个标签的状态

如果标签(event)没有设置，则线程会一直等待（此时wait是阻塞模式）

import threading 
# 创建线程event对象
e = threading.Event()

# 设置e, 使wait结束阻塞
e.wait([timeout]) 

# 阻塞等待e被set
e.set() 

# 使e回到未被设置状态
e.clear() 

# 查看当前e是否被设置
e.is_set() 

import threading
import time
import random
 
# 先定义一个灯的函数，由灯的线程去调用这个函数,绿灯是允许通过，红灯是不允许通过，其中绿灯10s，红灯也是10s,这里就要用到事件
# 如果是绿灯，则设置事件的状态，如果是红灯，则取消事件的状态，初始状态为红灯
def light(event):
    if event.is_set():
        #设置初始状态，该初始状态为事件没有状态，则进程一直会阻塞
        event.clear()
    count = 0
    while True:
        #进入交通灯灯循环的状态
        if count < 10:
            print("----red light on----")
        elif count < 20:
            print("----green light on----")
            if not event.is_set():
                event.set()
            else:
                pass
        else:
            count = 0
            if event.is_set():
                event.clear()
        count += 1
        time.sleep(1)
 
# 在定义一个车的函数，由车的线程去调用这个函数
def car(n,event):
    while True:
        time.sleep(1)
        if event.is_set():
            print("car [%(name)s] is running" %{"name":n})
        else:
            print("car [%(name)s] is waiting for red light" % {"name": n})
            event.wait()
 
 
if __name__ == '__main__':
    event = threading.Event()
    light_thread = threading.Thread(target=light,args=(event,))
    light_thread.start()
    for i in range(6):
        t = threading.Thread(target=car, args=[i,event])
        t.start()

线程锁 Lock

lock.acquire() 上锁 如果lock已经上锁再调用会阻塞
lock.release() 解锁
with lock: 上锁
…
…
with 代码块解锁自动解锁

from threading import Thread, Lock
a = b = 0
lock = Lock()
 
def value():
    while True:
        # 上锁
        lock.acquire()
        print('a=%d,b=%d' % (a, b)) if a != b else print('a不等于b')
        # 解锁
        lock.release()
 
t = Thread(target=value)
t.start()
while True:
    # with 开始上锁
    with lock:
        a += 1
        b += 1
    # with 解锁 自动解锁
t.join()
print('程序结束')

协程

协程，又称微线程，纤程。英文名Coroutine。一句话说明什么是线程：协程是一种用户态的轻量级线程。

协程的标准定义：

• 必须在只有一个单线程里实现并发
• 修改共享数据不需加锁
• 用户程序里自己保存多个控制流的上下文栈
• 一个协程遇到IO操作自动切换到其它协程

协程拥有自己的寄存器上下文和栈。协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈。因此，协程能保留上一次调用时的状态（即所有局部状态的一个特定组合），每次过程重入时，就相当于进入上一次调用的状态，换种说法：进入上一次离开时所处逻辑流的位置。线程是CPU控制的，而协程是程序自身控制的。

生成器(yield)

Python中的生成器本身就具有状态保存和恢复的功能，非常适合用来实现协程。生成器协程的最大特点在于使用yield语句来挂起函数并保存函数状态。

def simple_corouctine():
    print('-> corouctine started')
    x = yield   # yeild接收my_continue.send发送的信息
    print('-> corouctine received:',x)

# 调用协程
my_corouctine = simple_corouctine()
print(my_corouctine)
# 先启动协程，让协程处于暂停状态
next(my_corouctine) # 程序通过调用方法next()将生成器推进到第一个yield语句处
# 发送消息给协程，回复执行，打印消息
my_corouctine.send('hello world')

async/await

在Python 3.5版本以后，Python提供了原生的支持协程的语法async/await。它提供了更简洁的语法，更好的可读性。

import asyncio 

async def countdown(n):
    while n >0 :
        print(f'T-minux {n}')
        await asyncio.sleep(1)
        # yield from asyncio.sleep(1) # 效果同上
        n -=1
        
loop = asyncio.get_event_loop()
loop.run_until_complete(countdown(5))

import asyncio 

async def countdown(n,msg):
    while n >0 :
        print(f'{msg} - {n}')
        await asyncio.sleep(1)
        # yield from asyncio.sleep(1) # 效果同上
        n -=1
task_list = [
    asyncio.ensure_future(countdown(5,'A')),
    asyncio.ensure_future(countdown(2,'B')),
    asyncio.ensure_future(countdown(3,'C'))
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(task_list))

获取返回值

import asyncio

async def firstCorouctine(): # 定义协程
    await asyncio.sleep(1)
    return '34434'

# coroutine ：协同程序 
coroutine = firstCorouctine() # 将协程赋值给coroutine
task = asyncio.ensure_future(coroutine) # 封装为task
loop = asyncio.get_event_loop() # 获取事件循环
loop.run_until_complete(task) # 执行

return_value = task.result() # 获取协程返回值
print('协程返回的值为：{}'.format(return_value))

gevent（第三方库）

gevent是一个基于协程的Python网络库，它提供了一种基于yield的编程模型，允许程序员编写异步，非阻塞代码，且易于编写和测试。

安装gevent：pip install gevent

import gevent

def func1():
    print('func1 begin')
    gevent.sleep(3)
    print('func1 end')
 
def func2():
    print('func2 begin')
    gevent.sleep(2)
    print('func2 end')

def func3(no:int):
    print('func3 begin')
    gevent.sleep(2)
    print('func3 end')

g1 = gevent.spawn(func1)
g2 = gevent.spawn(func2)
g3 = gevent.spawn(func3,3) # 传参
 
gevent.joinall([g1, g2, g3])

monkey.path_all

在开头导入monkey.patch_all()，非常重要，会自动将 python 的一些标准模块替换成 gevent 框架，这个补丁其实存在着一些坑：

• monkey.patch_all()，网上一般叫猴子补丁。如果使用了这个补丁，gevent 直接修改标准库里面大部分的阻塞式系统调用，包括 socket、ssl、threading 和 select 等模块，而变为协作式运行。有些地方使用标准库会由于打了补丁而出现奇怪的问题（比如会影响 multiprocessing 的运行）
• 和一些第三方库不兼容（比如不能兼容 kazoo）。若要运用到项目中，必须确保其他用到的网络库明确支持Gevent。

在实际情况中协程和进程的组合非常常见，两个结合可以大幅提升性能，但直接使用猴子补丁会导致进程运行出现问题；将 thread 置成 False可以解决该问题，缺点是无法发挥 monkey.patch_all() 的全部性能。

import gevent
from gevent import monkey
monkey.patch_all(thread=False, socket=False, select=False)

pool 限制并发

协程虽然是轻量级线程，但并发数达到一定量级后，会把系统的文件句柄数占光。所以需要通过 Pool 来限制并发数。

import gevent
from gevent.pool import Pool
from gevent import monkey
monkey.patch_all()
import time,datetime

def test(tm):
    time.sleep(tm)
    print('时间：{}'.format(datetime.datetime.now()))

if __name__ =='__main__':
    task = []
    # 限制最大并发
    pool = Pool(5)
    # 分配100个任务，最大并发数为5
    for i in range(100):
        task.append(pool.spawn(test,5))
    gevent.joinall(task)

gevent 虽然在编程方面很方便，开头使用 monkey.patch_all()，就能让你的同步代码享受到异步的性能。但坑也是存在的，所以复杂的业务场景不推荐使用 gevent，可以使用python 标准库中的 asyncio。