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核数不一样可能是并行的，但是协程是在一个线程中 所以是并发