十五、Python 多任务-线程、进程和协程（迭代器、生成器）

1、线程

　　并发：指的是任务数多余cpu核数，通过操作系统的各种任务调度算法，实现用多任务‘’一起“执行。（实际上总有一些任务不在执行，因为切换速度很快，看似一起执行）

　　并行：指的是任务数小于等于cpu核数，即任务真的是一起执行的。

　　　　创建线程时，除了以下两种方法，还可以使用线程池的方法。

from multiprocessing.dummy import Pool
# 实现线程池需要借助于multiprocessing下的dummy模块


def proc_some(args):
    pass


if __name__=="__main__":
    pool = Pool(2)
    str_list = list()
    results = pool.map(proc_some,str_list)
    print(results)

　　1.1 创建线程

　　python通过threading模块实现线程控制

import time 
import threading 


def test1(def_name):
    for i in range(2):
        print('这是一个线程测试:%s，编号为 %d' % (def_name,i))
        time.sleep(1)

def test2(def_name):
    for i in range(2):
        print('这是一个线程测试:%s，编号为 %d' % (def_name,i))
        time.sleep(1)


def main():
    
    print('开始  {}'.format(time.ctime()))
    # 通过threading模块的Thread类创建一个线程对象
    # 这个对象接收两个参数,target=目标函数名,args为元组，包含传入函数的所有参数
    t1 = threading.Thread(target=test1,args=('test1',))
    t2 = threading.Thread(target=test2,args=('test2',))
    # 当调用start()时，才会真正的创建线程，并且开始执行
    t1.start()
    t2.start()

    # 查看线程数
    while True:
        length = len(threading.enumerate())
        # print('线程名：{}'.format(threading.enumerate()))
        print('当前运行的线程数为：{}'.format(length))
        if length<=1:
            break

    time.sleep(5)
    # 主线程会等待所有的子线程结束后才结束
    print('结束  {}'.format(time.ctime()))

if __name__=='__main__':
    main()

　　1.2 线程执行代码的封装

　　　　使用threading模块时，可以定义一个新的子类class,需要继承threading.Thread，并重写__inti__方法和run方法。

　　　　python的threading.Thread类有一个run方法，用于定义线程的功能函数，可以在自己的线程类中覆盖该方法。

　　　　创建子类实例后，通过Thread类的start方法，可以启动该线程，交给虚拟机进行调度，当该线程获得执行的机会时，就会调用run方法执行线程。

　　　　线程的执行顺序不能确定。

　　　　当线程的run()方法结束时该线程完成。

import threading
import time

class MyThread(threading.Thread):
    def run(self):
        for i in range(3):
            time.sleep(1)
            # python会自动为线程制定一个名字，通过self.name调用
            msg = "I'm "+self.name+' @ '+str(i)
            print(msg)
def test():
    for i in range(5):
        t = MyThread()
        t.start()
if __name__ == '__main__':
    test()

　　1.3 多线程共享全局变量

　　　　在一个进程内的所有线程共享全局变量，很方便在多个线程间共享数据。

　　　　缺点是：线程对全局变量随意改动可能造成多线程之间的全局变量混乱，此时线程不安全。

　　　　如果多个线程同时对同一个全局变量操作，会出现资源竞争问题，从而数据结果会不正确。

from threading import Thread
import time

def work1(nums):
    nums.append(44)
    print("----in work1---",nums)


def work2(nums):
    #延时一会，保证t1线程中的事情做完
    time.sleep(1)
    print("----in work2---",nums)

g_nums = [11,22,33]

t1 = Thread(target=work1, args=(g_nums,))
t1.start()

t2 = Thread(target=work2, args=(g_nums,))
t2.start()

　　1.4 同步

　　　　当多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制

　　　　线程同步能保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁。

　　　　互斥锁为资源引入一个状态：锁定/非锁定

　　　　当某个线程要更改共享数据时，先将其锁上，此时资源的状态为’锁定‘，其他线程不能更改，直到该线程释放资源，将资源的状态变成’非锁定‘，其他的线程才能再次锁定该资源。

　　　　互斥锁保证了每次只有一个线程进行写入操作，从而保证了多线程情况下数据的正确性。

　　　　对于Lock对象而言，如果一个线程连续两次进行acquire操作，那么由于第一次acquire之后没有release，第二次acquire将挂起线程，这会导致Lock对象永远不会release，使得线程死锁。RLock对象允许一个线程多次对其进程acquire操作，因为在其内部通过一个counter变量维护着线程acquire的次数，而且每一次的acquire操作必须有一个release操作与之对应，在所有的release操作完成之后，别的线程才能申请该RLock对象。

　　　　threading模块中定义了Lock类，可以方便的处理锁定：

# 创建锁
mutex = threading.Lock()

# 锁定
mutex.acquire()

# 释放
mutex.release()

# 使用互斥锁完成2个线程对同一个全局变量各加100万次的操作
import threading
import time

g_num = 0

def test1(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁

    print("---test1---g_num=%d"%g_num)

def test2(num):
    global g_num
    for i in range(num):
        mutex.acquire()  # 上锁
        g_num += 1
        mutex.release()  # 解锁

    print("---test2---g_num=%d"%g_num)

# 创建一个互斥锁
# 默认是未上锁的状态
mutex = threading.Lock()

# 创建2个线程，让他们各自对g_num加1000000次
p1 = threading.Thread(target=test1, args=(1000000,))
p1.start()

p2 = threading.Thread(target=test2, args=(1000000,))
p2.start()

# 等待计算完成
while len(threading.enumerate()) != 1:
    time.sleep(1)

print("2个线程对同一个全局变量操作之后的最终结果是:%s" % g_num)

　　1.5 案例：多线程聊天器

import threading
import socket


def recv_message(udp_socket):
    while True:
        recv_data = udp_socket.recvfrom(1024)
        print('接收到的消息：{}'.format(recv_data[0].decode('utf-8')))

def send_message(udp_socket,dest_addr):
    while True:
        send_data = input('请输入要发送的消息：')
        udp_socket.sendto(send_data.encode('utf-8'),dest_addr)


def main():
    """完成udp聊天器的整体控制"""
    # 创建套接字
    udp_socket = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    # 绑定本地地址
    localaddr = ('',8081)
    udp_socket.bind(localaddr)

    # 获取对方的地址
    dest_ip = input('请输入对方的ip:')
    dest_port = int(input('请输入对方的port：'))
    dest_addr = (dest_ip,dest_port)

    # 创建2个线程，去执行相应的功能
    t_recv = threading.Thread(target=recv_message,args=(udp_socket,))
    t_send = threading.Thread(target=send_message,args=(udp_socket,dest_addr))

    t_recv.start()
    t_send.start()


if __name__=='__main__':
    main()

2、进程

　　2.1 概念

　　　　进程：一个程序运行起来后，代码+用到的资源称为进程，它是操作系统分配资源的基本单位。

　　2.2 进程的状态

　　　　就绪态：运行的条件满足，正在等在cpu执行

　　　　执行态：cpu正在执行其功能

　　　　等待态：等待某些条件满足

　　2.3 进程的创建-multiprocessing

　　　　multiprocessing模块是多进程模块，提供了一个Process类来代表一个进程对象。

　　　　创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方式启动。

from multiprocessing import Process
import time

def run_proc():
    """子进程要执行的代码"""
    while True:
        print("---2---")
        time.sleep(1)

if __name__=='__main__':
    p = Process(target=run_proc)
    p.start()

    while True:
        print('---1---')
        time.sleep(1)

　　2.4 进程pid

from multiprocessing import Process
import os
import time

def run_proc():
    """子进程要执行的代码"""
    print('子进程运行中，pid=%d...' % os.getpid())  
    # os.getpid获取当前进程的进程号
    print('子进程将要结束...')

if __name__ == '__main__':
    print('父进程pid: %d' % os.getpid())  
    # os.getpid获取当前进程的进程号
    p = Process(target=run_proc)
    p.start()
    time.sleep(1)
    print('--父进程结束--')

　　2.5 Process语法结构如下：

　　　　Process(【group【，target【,name【,args【,kwargs】】】】】)

　　　　（1）target：如果传递了函数的引用，这个子进程就执行函数里的代码

　　　　（2）args：给target指定的函数传递的参数，以元组的方法传递

　　　　（3）kwargs：给target指定的函数传递命名参数

　　　　（4）name：给进程设定一个名字，可以不设定

　　　　（5）group：指定进程组，大多数情况下用不到

　　　　Process创建的实例对象的常用方法：

　　　　（1）start()：启动子进程实例（创建子进程）

　　　　（2）is_alive()：判断进程子进程是否还在活着

　　　　（3）join([timeout])：是否等待子进程执行结束，或等待多少秒

　　　　（4）terminate()：不管任务是否完成，立即终止子进程

　　　　Process创建的实例对象的常用属性：

　　　　（1）name：当前进程的别名，默认为Process-N,N为从1开始递增的整数

　　　　（2）pid：当前进程的pid（进程号）

from multiprocessing import Process
import os
from time import sleep


def run_proc(name, age, **kwargs):
    for i in range(10):
        print('子进程运行中，name= %s,age=%d ,pid=%d...' % (name, age, os.getpid()))
        print(kwargs)
        sleep(0.2)

if __name__=='__main__':
    p = Process(target=run_proc, args=('test',18), kwargs={"m":20})
    p.start()
    sleep(1)  # 1秒中之后，立即结束子进程
    p.terminate()
    p.join()

　　2.6 进程间不共享全局变量

　　2.7 进程间通信——Queue

　　　　2.7.0 Pipe的使用

　　　　　　Pipe常用来在两个进程间进行通信，两个进程分别位于管道的两端。

　　　　　　Pipe方法:`pipe = multiprocessing.Pipe()`，返回（conn1,conn2）代表一个管道的两个端。

　　　　　　Pipe方法有duplex参数，如果duplex参数为True(默认值)，那么这个管道是全双工模式，也就是说conn1和conn2均可收发。当duplex为False，conn1只负责接收消息,conn2只负责发送消息。send和recv方法分别是发送和接收消息的方法。

　　　　　　在全双工模式下，可以调用conn1.send发送消息，conn1.recv接收消息。如果没有消息可接收，recv方法会一直阻塞，如果管道已经被关闭，那么recv方法会抛出EOFError。

import multiprocessing
import random
import time,os


def proc_send(pipe,args):
    for arg_ in args:
        print("Process (%s) send: (%s)" % (os.getpid(),arg_))
        pipe.send(arg_)
        time.sleep(random.random())


def proc_recv(pipe):
    while True:
        print("Process (%s) recv: %s" % (os.getpid(), pipe.recv()))
        time.sleep(random.random())


if __name__=="__main__":
    pipe = multiprocessing.Pipe()
    p1 = multiprocessing.Process(target=proc_send, args=(pipe[0], ["da_da_da{}".format(str(i)) for i in range(10)]))
    p2 = multiprocessing.Process(target=proc_recv, args=(pipe[1],))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

　　　　2.7.1 Queue的使用

　　　　　　可以使用multiprocessing模块的Queue实现多进程之间的数据传递，Queue本身是一个消息队列程序。

from multiprocessing import Queue
q=Queue(3) #初始化一个Queue对象，最多可接收三条put消息
q.put("消息1") 
q.put("消息2")
print("Queue队列是否已满：",q.full())  #False
q.put("消息3")
print("Queue队列是否已满：",q.full()) #True

# 因为消息列队已满下面的try都会抛出异常，第一个try会等待2秒后再抛出异常，
# 第二个Try会立刻抛出异常
try:
    q.put("消息4",True,2)
except:
    print("消息列队已满，现有消息数量:%s"%q.qsize())

try:
    q.put_nowait("消息4")
except:
    print("消息列队已满，现有消息数量:%s"%q.qsize())

#推荐的方式，先判断消息列队是否已满，再写入
if not q.full():
    q.put_nowait("消息4")

#读取消息时，先判断消息列队是否为空，再读取
if not q.empty():
    for i in range(q.qsize()):
        print(q.get_nowait())

　　　　　　初始化Queue对象时（q=Queue()），若括号中没有指定最大可接收的消息数量，或数量为负值，那么就代表可接受的消息数量没有上限

　　　　　　Queue.qsize()：返回当前队列包含的消息数量

　　　　　　Queue.empty()：如果队列为空，返回True，反之False

　　　　　　Queue.full()：如果队列满了，返回True，反之False

　　　　　　Queue.get([block[,timeout]])：获取队列中的一条消息，然后将其从队列中移除，block默认值为True

　　　　　　　　1)如果block使用默认值，且没有设置timeout（单位秒），消息列队如果为空，此时程序将被阻塞（停在读取状态），直到从消息列队读到消息为止，如果设置了timeout，则会等待timeout秒，若还没读取到任何消息，则抛出"Queue.Empty"异常；

　　　　　　　　2)如果block值为False，消息列队如果为空，则会立刻抛出"Queue.Empty"异常

　　　　　　Queue.get_nowait()：相当于Queue.get(False)

　　　　　　Queue.put(item,[block[,timeout]])：将item消息写入队列，block默认为True

　　　　　　1)如果block使用默认值，且没有设置timeout（单位秒），消息列队如果已经没有空间可写入，此时程序将被阻塞（停在写入状态），直到从消息列队腾出空间为止，如果设置了timeout，则会等待timeout秒，若还没空间，则抛出"Queue.Full"异常

　　　　　　2)如果block值为False，消息列队如果没有空间可写入，则会立刻抛出"Queue.Full"异常

　　　　　　Queue.put_nowait(item)：相当于Queue.put(item,False)

# 父进程中创建两个子进程，一个往Queue里写数据，一个从Queue里读数据
from multiprocessing import Process, Queue
import os, time, random

# 写数据进程执行的代码:
def write(q):
    for value in ['A', 'B', 'C']:
        print('Put %s to queue...' % value)
        q.put(value)
        time.sleep(random.random())

# 读数据进程执行的代码:
def read(q):
    while True:
        if not q.empty():
            value = q.get(True)
            print('Get %s from queue.' % value)
            time.sleep(random.random())
        else:
            break

if __name__=='__main__':
    # 父进程创建Queue，并传给各个子进程：
    q = Queue()
    pw = Process(target=write, args=(q,))
    pr = Process(target=read, args=(q,))
    # 启动子进程pw，写入:
    pw.start()    
    # 等待pw结束:
    pw.join()
    # 启动子进程pr，读取:
    pr.start()
    pr.join()
    # pr进程里是死循环，无法等待其结束，只能强行终止:
    print('')
    print('所有数据都写入并且读完')

　　2.8 进程池Pool

　　　　通过multiprocessing模块提供的Pool方法创建进程池

from multiprocessing import Pool
import os, time, random

def worker(msg):
    t_start = time.time()
    print("%s开始执行,进程号为%d" % (msg,os.getpid()))
    # random.random()随机生成0~1之间的浮点数
    time.sleep(random.random()*2) 
    t_stop = time.time()
    print(msg,"执行完毕，耗时%0.2f" % (t_stop-t_start))

print("----start----")

po = Pool(3)  # 定义一个进程池，最大进程数3
for i in range(0,10):
    # Pool().apply_async(要调用的目标,(传递给目标的参数元祖,))
    # 每次循环将会用空闲出来的子进程去调用目标
    po.apply_async(worker,(i,))


po.close()  # 关闭进程池，关闭后po不再接收新的请求
po.join()  # 等待po中所有子进程执行完成，必须放在close语句之后
print("-----end-----")

　　　　multiporcessing.Pool常用函数解析：

　　　　（1）apply_async(func[, args[, kwds]]) ：使用非阻塞方式调用func（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给func的关键字参数列表

　　　　（2）close()：关闭Pool，使其不再接受新的任务

　　　　（3）terminate()：不管任务是否完成，立即终止

　　　　（4）join()：主进程阻塞，等待子进程的退出，必须在close或terminate之后使用

　　　　进程池中的Queue

　　　　　　如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：

　　　　　　RuntimeError: Queue objects should only be shared between processes through inheritance

# 修改import中的Queue为Manager
from multiprocessing import Manager,Pool
import os,time,random

def reader(q):
    print("reader启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
    for i in range(q.qsize()):
        print("reader从Queue获取到消息：%s" % q.get(True))

def writer(q):
    print("writer启动(%s),父进程为(%s)" % (os.getpid(), os.getppid()))
    for i in "itcast":
        q.put(i)

if __name__=="__main__":
    print("(%s) start" % os.getpid())
    q = Manager().Queue()  # 使用Manager中的Queue
    po = Pool()
    po.apply_async(writer, (q,))

    time.sleep(1)  # 先让上面的任务向Queue存入数据，然后再让下面的任务开始从中取数据

    po.apply_async(reader, (q,))
    po.close()
    po.join()
    print("(%s) End" % os.getpid())

　　2.9 案例：多进程版本的文件夹复制器

　　　　https://www.cnblogs.com/nuochengze/p/12639596.html

3、协程

　　3.1 迭代器

　　　　迭代是访问集合元素的一种方式，迭代器是一个可以记住遍历的位置的对象，迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束，迭代器只能往前不会后退

　　　　可以通过for...in...这类语句迭代读取一条数据供我们使用的对象称之为可迭代对象（Iterable）。

　　　　使用isinstance(item,Iterable)判断一个对象是否是Iterable对象。

　　　　可迭代对象的本质：可迭代对象通过__iter__方法向我们提供一个迭代器，我们在迭代一个迭代对象的时候，实际上就是先获取该对象提供的一个迭代器，然后通过这个迭代器来依次获取对象中的每一个数据。

　　　　一个具备了__iter__方法的对象，就是一个可迭代对象。

　　　　通过iter()函数获取可迭代对象的迭代器，对获取到的迭代器不断使用next()函数来获取下一条数据。

　　　　iter()函数实际上就是调用了可迭代对象的__iter__方法。

　　　　迭代器用来帮助我们记录每次迭代访问到的位置，当我们对迭代器使用next()函数的时候，迭代器会向我们返回它所记录位置的下一个位置的数据。

　　　　next()函数实际上就是调用了迭代器对象的__next__方法。

　　　　python要求迭代器本身也是可迭代的，所以我们要为迭代器实现__iter__方法，而__iter__方法要返回一个迭代器，迭代器自身正是一个迭代器，所以迭代器的__iter__方法返回自身即可。

　　　　一个实现了__iter__方法和__next__方法的对象，就是一个迭代器。

class MyList(object):
    """自定义的一个可迭代对象"""
    def __init__(self):
        self.items = []

    def add(self, val):
        self.items.append(val)

    def __iter__(self):
        myiterator = MyIterator(self)
        return myiterator


class MyIterator(object):
    """自定义的供上面可迭代对象使用的一个迭代器"""
    def __init__(self, mylist):
        self.mylist = mylist
        # current用来记录当前访问到的位置
        self.current = 0

    def __next__(self):
        if self.current < len(self.mylist.items):
            item = self.mylist.items[self.current]
            self.current += 1
            return item
        else:
            raise StopIteration

    def __iter__(self):
        return self


if __name__ == '__main__':
    mylist = MyList()
    mylist.add(1)
    mylist.add(2)
    mylist.add(3)
    mylist.add(4)
    mylist.add(5)
    for num in mylist:
        print(num)

　　　　for...in...循环的本质：for item in Iterable 循环的本质就是先通过iter()函数获取可迭代对象Iterable的迭代器，然后对获取到的迭代器不断调用next()方法来获取下一个值并将其赋值给item，当遇到StopIteration的异常后循环结束

　　　　除了for循环，list、tuple等也能接收可迭代对象：

　　　　li = list(FibIterator(15))
　　　　print(li)
　　　　tp = tuple(FibIterator(6))
　　　　print(tp)

　　3.2 生成器

　　　　生成器（generator）是一类特殊的迭代器。

　　　　3.2.1 创建生成器的方法

　　　　　　方法1：将列表推导的中括号[]换成圆括号()

　　　　　　方法2：只要函数中有关键字yield就称为生成器。

def fib(n):
    current = 0
    num1,num2 = 0, 1
    while current<n:
        num = num1
        num1,num2 = num2,num1+num2
        current+=1
        yield num
    return 'done'
#在使用生成器实现的方式中，我们将原本在迭代器__next__方法中实现的基本逻辑放到一个#函数中来实现，但是将每次迭代返回数值的return换成了yield，此时新定义的函数便不再是#函数，而是一个生成器了

# 输出
 next(fib(5))

# 输出
for n in fib(5):
    print(n)

#但是用for循环调用generator时，发现拿不到generator的return语句的返回值。如果想#要拿到返回值，必须捕获StopIteration错误，返回值包含在StopIteration的value中
g = fib(5)
while True:
    try:
        x=next(g)
        print('value:{}'.format(x))
    except StopIteration as e:
        print('生成器返回值：{}'.format(e.value))
        break

# 总结
使用了yield关键字的函数不再是函数，而是生成器。（使用了yield的函数就是生成器）

yield关键字有两点作用：
（1）保存当前运行状态（断点），然后暂停执行，即将生成器（函数）挂起
（2）将yield关键字后面表达式的值作为返回值返回，此时可以理解为起到了return的作用

可以使用next()函数让生成器从断点处继续执行，即唤醒生成器（函数）

Python3中的生成器可以使用return返回最终运行的返回值，而Python2中的生成器不允许使用return返回一个返回值（即可以使用return从生成器中退出，但return后不能有任何表达式）

　　　　3.2.2 使用send唤醒

　　　　　　除了可以使用next()函数来唤醒生成器继续执行外，还可以使用send()函数来唤醒执行。使用send()函数的一个好处是可以在唤醒的同时向断点处传入一个附加数据。

　　　　　　执行到yield时，gen函数作用暂时保存，返回i的值; temp接收下次c.send("python")，send发送过来的值，c.next()等价c.send(None)

　　3.3 协程

　　　　协程（Coroutine），又称微线程。

　　　　协程是python中另外一种实现多任务的方式，它自带CPU上下文，比线程更小占用更小执行单元。

　　　　协程和线程差异：在实现多任务时, 线程切换从系统层面远不止保存和恢复 CPU上下文这么简单。操作系统为了程序运行的高效性每个线程都有自己缓存Cache等等数据，操作系统还会帮你做这些数据的恢复操作。所以线程的切换非常耗性能。但是协程的切换只是单纯的操作CPU的上下文，所以一秒钟切换个上百万次系统都抗的住。

　　　　协程调度切换时，将寄存器上下文和栈保存到其他地方，在切回来的时候，恢复先前保存的寄存器上下文和栈，因此协程能保留上一次调用时的状态，每次过程重入时，就相当于进入上一次调用的状态。

　　　　并发编程中，协程和线程类似，每个协程表示一个执行单元，有自己的本地数据，与其他协程共享全局资源。

# 简单实现协程

import time

def work1():
    while True:
        print("----work1---")
        yield
        time.sleep(0.5)

def work2():
    while True:
        print("----work2---")
        yield
        time.sleep(0.5)

def main():
    w1 = work1()
    w2 = work2()
    while True:
        next(w1)
        next(w2)

if __name__ == "__main__":
    main()

# 运行结果

----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
----work1---
----work2---
...省略...

　　3.4 greenlet

　　　　为了更好使用协程来完成多任务，python中的greenlet模块对其封装，从而使得切换任务变的更加简单

from greenlet import greenlet
import time

def test1():
    while True:
        print "---A--"
        gr2.switch()
        time.sleep(0.5)

def test2():
    while True:
        print "---B--"
        gr1.switch()
        time.sleep(0.5)

gr1 = greenlet(test1)
gr2 = greenlet(test2)

#切换到gr1中运行
gr1.switch()

# 运行结果

---A--
---B--
---A--
---B--
---A--
---B--
---A--
---B--
...省略...

　　3.5 gevent

　　　　python有一个比greenlet更强大的并且能够自动切换任务的模块gevent。

　　　　gevent是一个基于协程的python网络函数库，使用greenlet在libev（libev是一个事件库）事件循环顶部提供了一个有高级别并发性的API。

　　　　gevent的主要特性：（1）基于libev的快速事件循环，Linux上是epoll机制。

　　　　　　　　　　　　　（2）基于greenlet的轻量级执行单元

　　　　　　　　　　　　　（3）API复用了python标准库里的内容

　　　　　　　　　　　　　（4）支持SSL的协作式sockets

　　　　　　　　　　　　　（5）可通过线程池或c-ares实现DNS查询

　　　　　　　　　　　　　（6）通过monkey patching功能使得第三方模块变成协作式（from gevent import monkey; mokey.patch_all()----类似于补丁）

　　　　其原理是当一个greenlet遇到IO(指的是input output 输入输出，比如网络、文件操作等)操作时，比如访问网络，就自动切换到其他的greenlet，等到IO操作完成，再在适当的时候切换回来继续执行。

　　　　由于IO操作非常耗时，经常使程序处于等待状态，有了gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待IO，这就是协程一般比多线程效率高的原因。由于切换是在IO操作时自动完成的，所以gevent需要修改python自带的一些标准库，将一些常见的阻塞，如socket、select等地方实现协程跳转，这一过程在启动时通过monkey.patch_all()完成。

　　　　spawn方法可以看成是用来形成协程，joinall方法就是添加这些协程任务并启动运行的。

# gevent同步执行
import gevent

def f(n):
    for i in range(n):
        print(gevent.getcurrent(), i)

g1 = gevent.spawn(f, 5)
g2 = gevent.spawn(f, 5)
g3 = gevent.spawn(f, 5)
g1.join()
g2.join()
g3.join()

# 结果
<Greenlet at 0x10e49f550: f(5)> 0
<Greenlet at 0x10e49f550: f(5)> 1
<Greenlet at 0x10e49f550: f(5)> 2
<Greenlet at 0x10e49f550: f(5)> 3
<Greenlet at 0x10e49f550: f(5)> 4
<Greenlet at 0x10e49f910: f(5)> 0
<Greenlet at 0x10e49f910: f(5)> 1
<Greenlet at 0x10e49f910: f(5)> 2
<Greenlet at 0x10e49f910: f(5)> 3
<Greenlet at 0x10e49f910: f(5)> 4
<Greenlet at 0x10e49f4b0: f(5)> 0
<Greenlet at 0x10e49f4b0: f(5)> 1
<Greenlet at 0x10e49f4b0: f(5)> 2
<Greenlet at 0x10e49f4b0: f(5)> 3
<Greenlet at 0x10e49f4b0: f(5)> 4

# gevent切换执行
import gevent

def f(n):
    for i in range(n):
        print(gevent.getcurrent(), i)
        #用来模拟一个耗时操作，注意不是time模块中的sleep
        gevent.sleep(1)

g1 = gevent.spawn(f, 5)
g2 = gevent.spawn(f, 5)
g3 = gevent.spawn(f, 5)
g1.join()
g2.join()
g3.join()

# 结果
<Greenlet at 0x7fa70ffa1c30: f(5)> 0
<Greenlet at 0x7fa70ffa1870: f(5)> 0
<Greenlet at 0x7fa70ffa1eb0: f(5)> 0
<Greenlet at 0x7fa70ffa1c30: f(5)> 1
<Greenlet at 0x7fa70ffa1870: f(5)> 1
<Greenlet at 0x7fa70ffa1eb0: f(5)> 1
<Greenlet at 0x7fa70ffa1c30: f(5)> 2
<Greenlet at 0x7fa70ffa1870: f(5)> 2
<Greenlet at 0x7fa70ffa1eb0: f(5)> 2
<Greenlet at 0x7fa70ffa1c30: f(5)> 3
<Greenlet at 0x7fa70ffa1870: f(5)> 3
<Greenlet at 0x7fa70ffa1eb0: f(5)> 3
<Greenlet at 0x7fa70ffa1c30: f(5)> 4
<Greenlet at 0x7fa70ffa1870: f(5)> 4
<Greenlet at 0x7fa70ffa1eb0: f(5)> 4

# 程序未打补丁
from gevent import monkey
import gevent
import random
import time

def coroutine_work(coroutine_name):
    for i in range(10):
        print(coroutine_name, i)
        time.sleep(random.random())

gevent.joinall([
        gevent.spawn(coroutine_work, "work1"),
        gevent.spawn(coroutine_work, "work2")
])

# 结果
work1 0
work1 1
work1 2
work1 3
work1 4
work1 5
work1 6
work1 7
work1 8
work1 9
work2 0
work2 1
work2 2
work2 3
work2 4
work2 5
work2 6
work2 7
work2 8
work2 9

# 程序打了补丁
from gevent import monkey
import gevent
import random
import time

# 有耗时操作时需要
monkey.patch_all()  # 将程序中用到的耗时操作的代码，换为gevent中自己实现的模块

def coroutine_work(coroutine_name):
    for i in range(10):
        print(coroutine_name, i)
        time.sleep(random.random())

gevent.joinall([
        gevent.spawn(coroutine_work, "work1"),
        gevent.spawn(coroutine_work, "work2")
])


# 结果
work1 0
work2 0
work1 1
work1 2
work1 3
work2 1
work1 4
work2 2
work1 5
work2 3
work1 6
work1 7
work1 8
work2 4
work2 5
work1 9
work2 6
work2 7
work2 8
work2 9

　　　　gevent中还提供了对池的支持，当拥有动态数量的greenlet需要进行并发管理（限制并发数）时，就可以使用池，在处理大量的网络和IO操作时时非常需要。

from gevent.pool import Pool
from gevent import monkey
monkey.patch_all()


def proc_some(args):
    pass


if __name__=="__main__":
    pool = Pool(2)
    str_list = ["hahah", 'hahahaaaa']
    results = pool.map(proc_some,str_list)
    print(results)

4、总结

进程是资源分配的单位
线程是操作系统调度的单位
进程切换需要的资源很最大，效率很低
线程切换需要的资源一般，效率一般（当然了在不考虑GIL的情况下）
协程切换任务资源很小，效率高
多进程、多线程根据cpu核数不一样可能是并行的，但是协程是在一个线程中所以是并发

posted @ 2020-04-06 00:28 Norni 阅读(958) 评论(0) 编辑收藏举报

刷新页面返回顶部

十五、Python 多任务-线程、进程和协程（迭代器、生成器）

1、线程

1.1 创建线程

1.2 线程执行代码的封装

1.3 多线程共享全局变量

1.4 同步

1.5 案例：多线程聊天器

2、进程

2.1 概念

2.2 进程的状态

2.3 进程的创建-multiprocessing

2.4 进程pid

2.5 Process语法结构如下：

2.6 进程间不共享全局变量

2.7 进程间通信——Queue

2.7.0 Pipe的使用

2.7.1 Queue的使用

2.8 进程池Pool

2.9 案例：多进程版本的文件夹复制器

3、协程

3.1 迭代器

3.2 生成器

3.2.1 创建生成器的方法

3.2.2 使用send唤醒

3.3 协程

3.4 greenlet

3.5 gevent

4、总结

公告

　　1.1 创建线程

　　1.2 线程执行代码的封装

　　1.3 多线程共享全局变量

　　1.4 同步

　　1.5 案例：多线程聊天器

　　2.1 概念

　　2.2 进程的状态

　　2.3 进程的创建-multiprocessing

　　2.4 进程pid

　　2.5 Process语法结构如下：

　　2.6 进程间不共享全局变量

　　2.7 进程间通信——Queue

　　　　2.7.0 Pipe的使用

　　　　2.7.1 Queue的使用

　　2.8 进程池Pool

　　2.9 案例：多进程版本的文件夹复制器

　　3.1 迭代器

　　3.2 生成器

　　　　3.2.1 创建生成器的方法

　　　　3.2.2 使用send唤醒

　　3.3 协程

　　3.4 greenlet

　　3.5 gevent