Python并发

Python是运行在解释器中的语言，查找资料知道，python中有一个全局锁（GIL），在使用多线程(Thread)的情况下，不能发挥多核的优势。而使用多进程(Multiprocess)，则可以发挥多核的优势真正地提高效率。

即便在多核心处理器上，使用GIL的解释器也只允许同一时间执行一个线程。总结：（Python是一门伪多线程语言）

为什么有GIL这个东西

GIL存在目的：为了解决多线程之间数据完整性和状态同步问题

GIL存在原因：Python中对象的管理，是使用引用计数器进行的，引用数为0则释放对象（涉及到Python的垃圾回收），简化了Python对共享资源的管理，如 PVM 内存。

import requests
import time
from threading import Thread
from multiprocessing import Processclass MyProcess(multiprocessing.Process):"""define my process must extends Process class"""def run(self):"""define work content"""pass

多线程在IO密集型的操作下似乎也没有很大的优势（也许IO操作的任务再繁重一些就能体现出优势），在CPU密集型的操作下明显地比单线程线性执行性能更差，但是对于网络请求这种忙等阻塞线程的操作，多线程的优势便非常显著了。

多进程无论是在CPU密集型还是IO密集型以及网络请求密集型（经常发生线程阻塞的操作）中，都能体现出性能的优势。不过在类似网络请求密集型的操作上，与多线程相差无几，但却更占用CPU等资源，所以对于这种情况下，可以选择多线程来执行。

import threading, timeclass Consumer(threading.Thread):def __init__(self):passdef run(self):pass

【Multiprocessing系列】共享资源

在使用多进程的过程中，最好不要使用共享资源，如果非得使用，则请往下看。Multiprocessing类中共享资源可以使用3种方式，分别是Queue，Array，Manager。这三个都是Multiprocessing自带的组件，使用起来也非常方便。注意：普通的全局变量是不能被子进程所共享的，只有通过Multiprocessing组件构造的数据结构可以被共享。

Queue类

使用Multiprocessing.Queue类，共享资源（share memory）（只适用Process类）

Array、Value类

使用Multiprocessing.Array类，共享资源（share memory）（只适用于Process类）

Manager类

使用Multiprocessing.Manager类，共享资源。（可以适用Pool类）

说明：由于windows操作系统下，创建Multiprocessing类对象代码一定要放在main()函数下，而linux不需要，因此这里区分2个版本。

实例目的：父进程在执行子进程的过程中，同步判断一个公共资源值，如果满足条件则结束所有进程。

进程安全变量

num=multiprocessing.Value("d",10.0) # d表示数值,主进程与子进程共享这个value。（主进程与子进程都是用的同一个value）

num=multiprocessing.Array("i",[1,2,3,4,5]) #主进程与子进程共享这个数组

mydict=multiprocessing.Manager().dict() #主进程与子进程共享这个字典

mylist=multiprocessing.Manager().list(range(5)) #主进程与子进程共享这个List

多进程Demo

Pool除了map()外，还有可以返回结果的方式，那就是apply_async().

apply_async()中只能传递一个值，它只会放入一个核进行运算，但是传入值时要注意是可迭代的，所以在传入值后需要加逗号, 同时需要用get()方法获取返回值

import multiprocessing as mpdef multicore():pool = mp.Pool()res = pool.map(job, range(5)) # 定义CPU核数量为5print(res)res = pool.apply_async(job, (2,)) # 用get获得结果print(res.get())def job(num):result = num * numreturn result

【ThreadPoolExecutor系列】

多线程并不能充分利用多核处理器。如果需要充分利用多核处理器，可以考虑使用multiprocessing模块进行多进程编程。

从 Python 3.2 开始提供 ThreadPoolExecutor 线程池执行器
创建池的最简单方法是作为上下文管理器，使用 with 语句来管理池的创建和销毁。
如果写过Java程序一定会觉得这个这类相当的熟悉。

import concurrent.futures# [rest of code]if __name__ == "__main__":format = "%(asctime)s: %(message)s"logging.basicConfig(format=format, level=logging.INFO,datefmt="%H:%M:%S")with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:executor.map(thread_function, range(3))
#       to_wait = {executor.submit(thread_function, **kwargs): idx for idx in range(total)}

线程安全

# 同步使用Lock
class FakeDatabase:def __init__(self):self.value = 0self._lock = threading.Lock()def locked_update(self, name):logging.info("Thread %s: starting update", name)logging.debug("Thread %s about to lock", name)with self._lock:logging.debug("Thread %s has lock", name)local_copy = self.valuelocal_copy += 1time.sleep(0.1)self.value = local_copylogging.debug("Thread %s about to release lock", name)logging.debug("Thread %s after release", name)logging.info("Thread %s: finishing update", name)

使用Condition进行线程间通信

import threading
import time# 共享资源
shared_resource = None# 创建条件变量
condition = threading.Condition()# 定义一个写线程
class WriterThread(threading.Thread):def run(self):global shared_resourcefor _ in range(5):with condition:shared_resource = "Write data"print("Writer wrote:", shared_resource)condition.notify()  # 通知等待的线程condition.wait()  # 等待其他线程通知# 定义一个读线程
class ReaderThread(threading.Thread):def run(self):global shared_resourcefor _ in range(5):with condition:while shared_resource is None:condition.wait()  # 等待写线程通知print("Reader read:", shared_resource)shared_resource = Nonecondition.notify()  # 通知写线程# 创建写线程和读线程
writer_thread = WriterThread()
reader_thread = ReaderThread()# 启动线程
writer_thread.start()
reader_thread.start()# 主线程等待所有子线程结束
writer_thread.join()
reader_thread.join()print("Main thread exiting")