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 greenletcode：
# 导入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 geventcode:
# 导入所需要的模块
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)])
来源：oschina
链接：https://my.oschina.net/u/4397463/blog/3827712