首先，推荐一篇讲解进程与线程关系的漫画：http://www.ruanyifeng.com/blog/2013/04/processes_and_threads.html
线程
在平时，我们如果要执行一个任务，需要排队执行，但是我们有了线程和进程就不一样了。比如，公司只有我和老板，有一天，老板给我派任务了，只有我一个人来做任务，用了一天完成，这就叫单线程；又有一天，老板又派了同样的任务，并且招了好几个技术人员，让我和他们一起完成任务，结果只用了一个小时，这就叫多线程。
我们写一段代码，编译器从上到下读的过程叫主线程，遇到threading.Thread就叫子线程。
threading模块
threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。
import threading import time def worker(num): time.sleep(1) print("Thread %d" % num) for i in range(10): #args里面的参数必须是元组 t = threading.Thread(target=worker,args=(i,),name = "t.%d" % i) t.start() print(t.name)#线程名
上述代码中创建了10个线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行命令。
- start 线程准备就绪，等待CPU调度
- setName 为线程设置名称
- getName 获取线程名称
- setDaemon 设置为后台线程或前台线程（默认）
如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
- join 逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
- run 线程被cpu调度后自动执行线程对象的run方法
setdaemon：不等待子线程执行完就关闭
import threading import time def f0(): pass def f1(a1,a2): time.sleep(10) f0() t1 = threading.Thread(target=f1,args=(123,111)) t1.setDaemon(True) t1.start() t2 = threading.Thread(target=f1,args=(123,111)) t2.setDaemon(True) t2.start() t3 = threading.Thread(target=f1,args=(123,111)) t3.setDaemon(True) t3.start()
等待子线程执行完毕才关闭
import threading import time def f0(): print("f0") def f1(a1,a2): time.sleep(10) f0() t1 = threading.Thread(target=f1,args=(123,111)) t1.start() t2 = threading.Thread(target=f1,args=(123,111)) t2.start() t3 = threading.Thread(target=f1,args=(123,111)) t3.start()
join：等当前线程执行结束后再执行下一个线程，可传参数，参数表示最多等的秒数
import threading import time def f0(): print("f0") def f1(a1,a2): print("f1") f0() t1 = threading.Thread(target=f1,args=(123,111)) t1.start() t1.join() t2 = threading.Thread(target=f1,args=(123,111)) t2.start() t2.join()
线程锁
我们使用线程对数据进行操作的时候，如果多个线程同时修改某个数据，可能会出现脏数据（不准确的数据），为了保证数据的准确性，就需要加把锁。
锁有两种：RLock和Lock，这里我们使用RLock。
import threading import time globals_num = 0 lock = threading.RLock() def func(): lock.acquire() # 获得锁 global globals_num globals_num +=1 time.sleep(1) print(globals_num) lock.release() #释放锁 for i in range(10): r = threading.Thread(target=func)#创建线程锁 r.start()
RLock和Lock的区别：
Lock：获得锁之后必须释放锁才能再次获得锁，不然会产生死锁，就会一直等待释放锁。
import threading lock = threading.Lock() lock.acquire() lock.acquire() #产生死锁 lock.release() lock.release() import threading lock = threading.Lock() lock.acquire() print("1") lock.release() print("ok") lock.acquire() print("2") lock.release()
RLock：获得几把锁就要释放几把锁。
import threading rlock = threading.RLock() rlock.acquire() rlock.acquire() rlock.release() rlock.release() print("end") import threading rlock = threading.RLock() rlock.acquire() print("1") rlock.acquire() print("2") rlock.release() print("3") rlock.release() print("4")
event
Python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法：set、wait、clear。
事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait 方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。
- clear：将“Flag”设置为False
- set：将“Flag”设置为True
- wait：阻塞线程，直到event对象内部标识位被设为True时。
import threading def do(event): print('start') event.wait() print('execute') event_obj = threading.Event() for i in range(10): t = threading.Thread(target=do, args=(event_obj,)) t.start() event_obj.clear() inp = input('input:') if inp == 'true': event_obj.set()
queue模块
Queue就是队列，规则是先进先出。这个模型也叫生产者-消费者模型。
生产者-消费者：创建一个为10的队列，生产12个，只消费10个。
import queue import threading message = queue.Queue(10) # 创建队列 def producer(i): print("put:",i) message.put(i) def consumer(i): print("get:",i) msg = message.get() for i in range(12): t = threading.Thread(target=producer, args=(i,)) t.start() for i in range(10): t = threading.Thread(target=consumer, args=(i,)) t.start()
join：等到队列为空时，再继续往下执行
put(item, block=True, timeout=None)：放入队列尾部
get(block=True, timeout=None)：获取队列第一个值
put_nowait：等效于 put(item,block=False)
get_nowait：等效于 get(item,block=False)
线程池
先说一下线程池是什么鬼！之所以这么说，是因为我本以为很简单的东东，结果好复杂...但是！懂了之后，又觉得还好还好，没有特别难。其实就是用最少的劳动力，创造出最多的利益！线程池里面有很多线程，同时还有一个任务队列。执行任务过程就是，也就是说重复利用线程来执行任务，减少系统资源的开销。
简单版线程池是线程执行完任务之后销毁，如果还有任务，就再创建线程去执行。
高级版线程池就是线程执行完任务之后回来告诉回调函数执行完毕，回调函数不销毁它，而是把它作为空闲线程，不用创建新线程，如果任务队列中还有任务，就让它再去执行任务。
so easy！妈妈再也不用担心我会掉进各种池啦......
简易版线程池（武大神说这是low版本）：
import queue import threading import time class ThreadPool(object): def __init__(self,max_num=20): self.queue = queue.Queue(max_num) # 长度为20的队列 for i in range(max_num): self.queue.put(threading.Thread) # threading.Thread是类对象，放入队列中 def get_thread(self): return self.queue.get() #获取队列中的类对象 def add_thread(self): self.queue.put(threading.Thread) def func(pool,a1): time.sleep(1) print(a1) pool.add_thread() p = ThreadPool(10) for i in range(50): thread = p.get_thread() #threading.Thread #得到一个线程 t = thread(target=func,args=(p,i)) # 执行func函数 t.start()
高级版线程池：
import queue import threading import contextlib import time StopEvent = object() class ThreadPool(object): def __init__(self, max_num): self.q = queue.Queue() # 创建队列 self.max_num = max_num # 最多创建线程数量 self.terminal = False # 默认为False self.generate_list = [] # 实际创建的线程 self.free_list = [] # 空闲的线程 def run(self, func, args, callback=None): """ 线程池执行一个任务 :param func: 任务函数 :param args: 任务函数所需参数 :param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；2、任务函数返回值（默认为None，即：不执行回调函数） :return: 如果线程池已经终止，则返回True否则None """ if len(self.free_list) == 0 and len(self.generate_list) < self.max_num: # 如果空闲列表为0并且实际创建的线程列表长度小于最多创建的线程数 self.generate_thread() # 创建线程 w = (func, args, callback,) # 将任务元组赋值给w变量 self.q.put(w) # 将任务放入队列中 def generate_thread(self): """ 创建一个线程 """ t = threading.Thread(target=self.call) t.start() def call(self): """ 循环去获取任务函数并执行任务函数 """ current_thread = threading.currentThread # 创建当前线程 self.generate_list.append(current_thread) # 将线程添加到实际创建线程列表中 event = self.q.get() # 等待着去队列中获取线程 while event != StopEvent: # 队列中没有停止符 func, arguments, callback = event # 获得任务 try: result = func(*arguments) #函数 status = True #赋值True except Exception as e: status = False # 发生错误赋值False result = e # 错误类型 if callback is not None: # 回调函数不为空 try: callback(status, result) # 执行回调函数 except Exception as e: pass if self.terminal: # False event = StopEvent else: with self.worker_state(self.free_list,current_thread): #with：上下文管理 event = self.q.get() #before：append；after：remove else: self.generate_list.remove(current_thread) #没有任务时，就把实际创建线程列表里的线程删掉 @contextlib.contextmanager # 可以实现上下文管理的装饰器 def worker_state(self, lis, val): lis.append(val) try: yield finally: lis.remove(val) def close(self): num = len(self.generate_list) #时间创建线程列表长度 while num: self.q.put(StopEvent) #停止符放入已创建的线程中 num -= 1 # 终止线程（清空队列） def terminate(self): self.terminal = True while self.generate_list: self.q.put(StopEvent) self.q.empty() def work(i): print(i) pool = ThreadPool(10) for item in range(50): pool.run(func=work, args=(item,)) pool.terminate() # 执行一下就关闭
ps：这里要补充一个知识点。
实现上下文管理（高级版本线程池中有出现）。需要导入模块，然后加上装饰器就ok。
示例：
import contextlib @contextlib.contextmanager def myopen(file_path,mode): f = open(file_path,mode,encoding="utf-8") try: yield f finally: f.close()
with myopen("index.html","r") as file_obj: print(file_obj.readline())
进程
注：由于进程之间的数据需要各自持有一份，所以创建进程需要非常大的开销，也就是占有很大的内存。同一个进程中，线程跟线程之间的内存是共享的。
创建进程：multiprocessing模块
from multiprocessing import Process def f(name): print("hello",name) if __name__ == "__main__": p = Process(target=f,args=("bob",)) p.start() print("start") p.join() # 等待 print("end")
实现进程数据共享
#默认数据没有共享 from multiprocessing import Process,Manager def Foo(i,dic): dic[i] = 100 + i print(dic) for k,v in dic.items(): print(k,v) if __name__ == "__main__": manage = Manager() dic = {} for i in range(2): p = Process(target=Foo,args=(i,dic,)) p.start() p.join() #打印结果： {0: 100} 0 100 {1: 101} 1 101
#实现数据共享 from multiprocessing import Process,Manager def foo(i,dic): dic[i] = 100 + i print(dic) print(len(dic)) if __name__ == "__main__": manage = Manager() dic = manage.dict() for i in range(2): p = Process(target=foo,args=(i,dic,)) p.start() p.join() #打印结果： {0: 100} 1 {0: 100, 1: 101} 2
'c': ctypes.c_char, 'u': ctypes.c_wchar, 'b': ctypes.c_byte, 'B': ctypes.c_ubyte, 'h': ctypes.c_short, 'H': ctypes.c_ushort, 'i': ctypes.c_int, 'I': ctypes.c_uint, 'l': ctypes.c_long, 'L': ctypes.c_ulong, 'f': ctypes.c_float, 'd': ctypes.c_double
进程池
进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池程序中没有可供使用的进程，那么进程就会等待，直到进程池中有可用进程为止。
进程池中有两个方法：apply_async、apply
apply_async:
一次创建多个进程，并发执行，执行完一个将返回值给回调函数然后执行回调函数
from multiprocessing import Pool import time def f1(a): time.sleep(1) print(a) return 1000 def f2(arg): print(arg) if __name__ == "__main__": pool = Pool(5) for i in range(10): pool.apply_async(func=f1,args=(i,),callback=f2) print("111111") pool.close() pool.join()
join:进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。
apply:
#排队执行，apply里面有join from multiprocessing import Pool import time def f1(a): time.sleep(1) print(a) if __name__ == "__main__": pool = Pool(5) for i in range(10): pool.apply(func=f1,args=(i,)) print("111111")
进程与线程之间的关系
线程是属于进程的，线程运行在进程空间内，并且同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。不管是进程还是线程，都是为了实现一个并发操作。
io密集型：使用线程；计算密集型：使用进程。根本的原因是Python的线程里面有个锁（只有Python里有这个锁：GIL）：全局解释器锁，规定进程里面只有一个线程能出来被CPU调用。
协程
线程在执行任务时，发现要等一段时间才能得到结果，就不等结果，再去执行其他任务。
线程和进程的操作是由程序触发系统接口，最后的执行者是系统；协程的操作则是程序员。
协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某个代码块执行顺序。
协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程；
gevent
手动版协程：为了看出执行任务时需要等待，所以我们就睡一会咯（gevent.sleep）
import gevent def foo(): print("1") gevent.sleep() #表示暂停，去执行下一个 print("3") def bar(): print("2") gevent.sleep() print("4") gevent.joinall([ gevent.spawn(foo), gevent.spawn(bar), ]) #打印结果： 1 2 3 4
终极版协程：终极版就是不用手动让它睡一会就能看出效果的版本！
from gevent import monkey; monkey.patch_all() import gevent import requests def f(url): print('GET: %s' % url) resp = requests.get(url) data = resp.text print(url,len(data)) gevent.joinall([ gevent.spawn(f, 'https://www.python.org/'), gevent.spawn(f, 'https://www.yahoo.com/'), gevent.spawn(f, 'https://baidu.com/'), ]) #执行结果：需要大家自己去执行才能感同身受呢！！！