1、python的多线程
多线程就是在同一时刻执行多个不同的程序，然而python中的多线程并不能真正的实现并行，这是由于cpython解释器中的GIL(全局解释器锁)捣的鬼，这把锁保证了同一时刻只有一个线程被执行。
多线程的特点：
线程比进程更轻量级，创建一个线程要比创建一个进程快10-100倍。
线程共享全局变量。
由于GIL的原因，当一个线程遇到IO操作时，会切换到另一个线程，所以线程适合IO密集型操作。
在多核cpu系统中，最大限度的利用多核，可以开启多个线程，开销比进程小的多，但是这并不适合python。
多线程互斥锁：
因为线程共享全局变量，所以需要互斥锁去限制线程对全局变量的更改。
假设，当一个线程在执行到获取全局变量的时候，这个后GIL切换到另一个线程执行，这个时候新的线程为全局变量+1后切换回之前的线程，之前的线程中的全局变量还是+1前的值，所以需要互斥锁。
为什么有了GIL锁还要互斥锁呢？
GIL锁只是控制同一时刻下只有一个线程被执行，这并不能控制同一时刻只有一个线程去获取并更改全局变量，所以需要使用互斥锁。
多线程的实现：
# 导入threading模块 import threading # 定义全局变量 i=0 # 定义互斥锁 mutex = threading.Lock() def a(): # 申明全局变量i global i for j in range(2000000): # 获取互斥锁 mutex.acquire() i+=1 # 释放互斥锁 mutex.release() def b(): global i for j in range(2000000): mutex.acquire() i+=1 mutex.release() # 创建线程 t1 = threading.Thread(target=a) t2 = threading.Thread(target=b) # 开启线程 t1.start() t2.start() # 等待所有线程结束 t1.join() t2.join() print(i)
2、python中的多进程
python的多线程不能利用多核的优势，如果想要充分的利用多核cpu的资源，python中大部分情况需要使用多进程。
python多进程的特点：
进程间不共享全局变量，进程修改的数据仅限于该进程内。
进程创建和销毁的开销比较大。
相对于线程，进程更适合与计算密集型操作。
能充分利用多核的优势。
进程间通信：
既然进程间中不公共享全局变量，那么多进程间怎么进行通信呢？可以使用multiprocessing中的Queue模块，当然也可以使用socket、管道、共享内存等方式。
多进程的实现：
# 导入multiprocessin模块 import multiprocessing # 创建队列 queue = multiprocessing.Queue() # 定义全局变量 a = 0 # 定义函数 def work1(num): # 获取队列中的数据，如果没有数据，将堵塞 a = queue.get() # 将队列中的数据+2000000次num for i in range(2000000): a+=num # 将数据存放在队列中 queue.put(a) # 打印最终结果 print("work1",a) # 定义函数 def work2(): # 申明全局变量a global a # 将a+2000000次1 for i in range(2000000): a+=1 # 打印最总结果 print("work2",a) # 将a存放在队列中 queue.put(a) # 创建进程 p1 = multiprocessing.Process(target=work1, args=(2,)) p2 = multiprocessing.Process(target=work2) # 启动进程 p1.start() p2.start() # 等待进程结束 p1.join() p2.join() # 获取队列中的数据 a = queue.get() # 打印a print(a)
进程池的实现
进程池能减少重复创建和销毁进程的开销问题
# 导入需要的模块 import multiprocessing import time import random # 定义函数 def work(num): print("num=",num) time.sleep(random.randint(0,2)) # 创建进程池，设置进程的数量 pool = multiprocessing.Pool(3) for i in range(10): # 开启进程 pool.apply_async(work, args=(i,)) # 设置等待时间，等待所有进程结束 time.sleep(20)
3、python中的协程
在linux中线程就是轻量级的进程，而我们通常也把协程称为轻量级的线程。
对比进程和协程：
进程是内核调度，而协程是在用户态调度，所以说进程的上下文在内核态保存恢复，而协程是在用户态保存恢复的，所以协程的开销比进程低。
进程会被抢占，而协程不会，也就是说协程如果不主动让出cpu，那么其他的协程就没有执行的机会。
进程所需要的内存比协程大得多
对比线程和协程：
线程的上下文切换成本相对于协程来说比较高。
线程的切换由操作系统来控制，而协程的切换由我们自己控制。
yield实现协程：
# 定义两个函数 def work1(): while True: print("work1") # 当程序运行到yield就会暂停，等待下次的next调用，然后继续执行 yield def work2(): while True: print("work2") yield w1 = work1() w2 = work2() while True: # 使用next函数启动 next(w1) next(w2)
greenlet实现协程：
greenlet安装：
sudo pip3 install greenlet
code：
# 导入greenlet模块 from greenlet import greenlet def work1(): for i in range(10): print("work1") # 打印过后跳转至协程g2继续执行 g2.switch() def work2(): for i in range(10): print("work2") # 打印后跳转至协程g1继续执行 g1.switch() # 创建协程g1 g1 = greenlet(work1) # 创建协程g2 g2 = greenlet(work2) # 跳转至协程g1 g1.switch()
gevent实现协程：
gevent是基于greenlet的并发网络库，每当有一个协程堵塞的时，程序将自动调度。
monkey-patching：
一般称为猴子补丁，这个补丁能直接修改标准库里面大部分的阻塞式系统调用。但是如果在复杂的生产环境中使用了这些标准库，可能就会因为打了补丁而出现奇怪的问题。
gevent安装：
sudo pip3 install gevent
code:
# 导入所需要的模块 import gevent import time from gevent import monkey # 猴子补丁，monkey.patch_all()方法将所有的标准库都替换掉 # 使用猴子补丁褒贬不一，但是官网上还是建议使用patch_all()，而且在程序的第一行就执行 monkey.patch_all() def f(n): for i in range(n): print(i) # 设置延时 time.sleep(0.5) # 如果没有导入monkey模块的话，需要使用gevent.sleep() # gevent.sleep(0.5) # ----------------写法一-------------------- # 创建greenlet协程对象 # g1 = gevent.spawn(f,5) # g2 = gevent.spawn(f,5) # g3 = gevent.spawn(f,5) # 等待所有greenlet携程结束后退出 # g1.join() # g2.join() # g3.join() # ----------------写法二-------------------- gevent.joinall([gevent.spawn(f,5), gevent.spawn(f,5), gevent.spawn(f,5)])