一、进程
1.1 进程的引入
现实生活中，有很多的场景中的事情是同时进行的，比如开车的时候 手和脚共同来驾驶汽车，再比如唱歌跳舞也是同时进行的；试想，如果把唱歌和跳舞这2件事情分开依次完成的话，估计就没有那么好的效果了（想一下场景：先唱歌，然后在跳舞，O(∩_∩)O哈哈~）
程序中
如下程序，来模拟“唱歌跳舞”这件事情
# 模拟唱歌，跳舞 from time import sleep def sing(): for i in range(3): print("正在唱歌...%d"%i) sleep(1) def dance(): for i in range(3): print("正在跳舞...%d"%i) sleep(1) if __name__ == '__main__': sing() # 唱歌 dance() # 跳舞
运行结果
注意
很显然刚刚的程序并没有完成唱歌和跳舞同时进行的要求
如果想要实现“唱歌跳舞”同时进行，那么就需要一个新的方法，叫做：多任务
1.2 多任务的概念
什么叫“多任务”呢？简单地说，就是操作系统可以同时运行多个任务。打个比方，你一边在用浏览器上网，一边在听MP3，一边在用Word赶作业，这就是多任务，至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行着，只是桌面上没有显示而已。
现在，多核CPU已经非常普及了，但是，即使过去的单核CPU，也可以执行多任务。由于CPU执行代码都是顺序执行的，那么，单核CPU是怎么执行多任务的呢？
答案就是操作系统轮流让各个任务交替执行，任务1执行0.01秒，切换到任务2，任务2执行0.01秒，再切换到任务3，执行0.01秒……这样反复执行下去。表面上看，每个任务都是交替执行的，但是，由于CPU的执行速度实在是太快了，我们感觉就像所有任务都在同时执行一样。
真正的并行执行多任务只能在多核CPU上实现，但是，由于任务数量远远多于CPU的核心数量，所以，操作系统也会自动把很多任务轮流调度到每个核心上执行。
其实就是CPU执行速度太快啦。。
1.2.1 进程
每个独立执行的程序称为进程
进程是程序的一次动态执行过程，它经历了从代码加载、执行到执行完毕的一个完整过程，这个过程也是进程本身从产生、发展到最终消亡的过程。
多进程(多任务)操作系统能同时运行多个进程（程序），由于CPU具备分时机制，所以每个进程都能循环获得自己的CPU时间片。由于CPU执行速度非常快，使得所有程序好象是在“同时”运行一样。
在操作系统中进程是进行系统资源分配、调度和管理的最小单位，进程在执行过程中拥有独立的内存单元。
比如：Windows采用进程作为最小隔离单位，每个进程都有自己的数据段、代码段，并且与别的进程没有任何关系。因此进程间进行信息交互比较麻烦。
进程也可以通过派生 （fork 或 spawn）新的进程来执行其他任务，不过因为每个新进程也都拥有自己的内存和数据 栈等，所以只能采用进程间通信（IPC）的方式共享信息。
1.2.2 线程
为了解决进程调度资源的浪费，为了能够共享资源，出现了线程。有时候把线程称之为轻量级进程.
线程是CPU调度和分派的基本单位，它可与同属一个进程的其他的线程共享进程所拥有的全部资源，多个线程共享内存，从而极大地提高了程序的运行效率。
线程是比进程更小的执行单位，线程是进程内部单一的一个顺序控制流。
所谓多线程是指一个进程在执行过程中可以产生多个线程，这些线程可以同时存在、同时运行，形成多条执行线索。一个进程可能包含了多个同时执行的线程。
一个或更多的线程构成了一个进程（操作系统是以进程为单位的，而进程是以线程为单位的，进程中必须有一个主线程main）
如果一个进程没有了，那么这个进程内的所有线程肯定会消失，如果线程消失了，但是进程未必会消失。只有所有的线程都结束了，进程才会结束！！！而且所有线程都是在进程的基础之上同时运行。
1.3 Python 和并发编程
在大多数系统上, Python支持多进程(基于消息传递)编程和多线程编程.
大多数人比较熟悉的是多线程编程, 但是在python中的多线程编程却是有诸多的限制.
python中多线程的限制
为了线程安全考虑, python的解释器还是使用了内部的GIL(Global Interperter Lock, 全局解释器锁定), 在任意时刻只运行单个python的线程执行.即使有多个可用的cpu核心, 也是如此.这就限制了python只能在一个cpu核心上运行.
GIL的存在直接影响了程序的并发编程问题.
如果一个应用程序是大部分与I/O相关, 那么使用线程一般没有问题, 因为大部分时间是在I/O等待.
如果一个应用程序是CPU密集型的, 则使用多线程的坏处大于好处, 返回会降低程序的运行速度, 一般比你想象的还要慢的多.
因此, 用户在有些情况需要使用多进程(子进程和消息传递)
子进程和消息传递 展望未来, 如果要再python中进行各种类型的并发编程, 消息传递应该是最应该掌握的概念.
1.4 multiprocessing包
multiprocessing是一个package, 这个包支持使用类似threading模块的类似API去创建新的进程.
multiprocessing支持本地和远程并发编程, 通过使用子进程来代替线程高效的规避了GIL问题.
所以, multiprocessing允许程序员重复利用给定计算机的多核cpu.
由于python的跨平台, 所以multiprocessing支持多个平台:unix, window, linux.
1.4.1 Process类
Process语法结构如下：
Process([group [, target [, name [, args [, kwargs]]]]])
target：表示这个进程实例所调用对象；
args：表示调用对象的位置参数元组；
kwargs：表示调用对象的关键字参数字典；
name：为当前进程实例的别名；
group：大多数情况下用不到；
最简单的使用代码:
# 从multiprocessing中导入Process from multiprocessing import Process import os # 子进程要执行的代码 def run_proc(name): print('子进程运行中，hello,= %s ,pid=%d...' % (name, os.getpid())) if __name__ == '__main__': # 判断是否为主程序 print('父进程 %d.' % os.getpid()) """ 创建Process对象, 表示一个子进程. 1. target参数表示子进程要做的任务(一个可执行对象) 2. args是一个元组, 表示传递给target的可执行对象的位置参数. 本例中就是把"王二狗"传递给函数f的name参数 """ p = Process(target=run_proc, args=('王二狗',)) print('子进程将要执行。。') p.start() # 启动子进程 p.join() # 等待进程终止 print("子进程已经终止")
说明
创建子进程时，只需要传入一个执行函数和函数的参数，创建一个Process实例，用start()方法启动。
join()方法可以等待子进程结束后再继续往下运行，通常用于进程间的同步。
1.4.1.1 Process类的实例具有以下方法
Process实例p具有以下方法:
p.start()
启动子进程. 这将运行代表进程的子进程, 并调用该子进程中的p.run()方法.
p.join([timeout])
等待进程p终止, timeout是可选的超时时间. 这个方法通常用户进程间的同步.
p.is_alive()
测试进程p是否还在运行, 如果扔在运行, 则返回True
run()：
如果没有给定target参数，对这个对象调用start()方法时，就将执行对象中的run()方法；
p.terminate()
强制终止p进程. 如果调用此方法, 进程p将立即被终止, 同时不会进行任何清理工作. 如果再进程p中也开启了子进程, 则这些子进程将成为僵死进程.s如果p保存了一个锁定或有进程间通信, 那么终止可能会导致死锁或I/O崩溃.
1.4.1.2 Process实例具有以下实例属性:
Process实例p具有以下实例属性:
p.daemon
一个布尔标志, 指示这个进程是否为后台进程. 当创建他的python进程终止时, 后台进程将自动终止.
另外禁止后台进程创建自己的新进程. p.daemon的值必须再进程启动前设置.
p.exitcode
进程的整数退出码. 如果进程仍在运行, 则它的值是None. 如果是负数, -N表示由信号N所终止
p.name
当前进程实例别名，默认为Process-N，N为从1开始递增的整数；
p.pid
进程的整数ID
1.4.1.3 实例
实例1：
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.5) if __name__=='__main__': print('父进程 %d.' % os.getpid()) p = Process(target=run_proc, args=('test',18), kwargs={"m":20}) print('子进程将要执行') p.start() sleep(1) p.terminate() p.join() print('子进程已结束')
运行结果：
实例2：
from multiprocessing import Process import time import os # 两个子进程将会调用的两个方法 def worker_1(interval): print("worker_1,父进程(%s),当前进程(%s)"%(os.getppid(), os.getpid())) t_start = time.time() time.sleep(interval) # 程序将会被挂起interval秒 t_end = time.time() print("worker_1,执行时间为'%0.2f'秒" % (t_end - t_start)) def worker_2(interval): print("worker_2,父进程(%s),当前进程(%s)" % (os.getppid(), os.getpid())) t_start = time.time() time.sleep(interval) t_end = time.time() print("worker_2,执行时间为'%0.2f'秒" % (t_end - t_start)) if __name__ == '__main__': # 判断是否为主程序 # 输出当前程序的ID print("进程ID：%s" % os.getpid()) """ 创建两个进程对象，target指向这个进程对象要执行的对象名称， args后面的元组中，是要传递给worker_1方法的参数， 因为worker_1方法就一个interval参数，这里传递一个整数2给它， 如果不指定name参数，默认的进程对象名称为Process-N，N为一个递增的整数 """ p1=Process(target=worker_1, args=(2,)) p2=Process(target=worker_2, name="王二狗", args=(1,)) # 使用"进程对象名称.start()"来创建并执行一个子进程， # 这两个进程对象在start后，就会分别去执行worker_1和worker_2方法中的内容 p1.start() p2.start() # 同时父进程仍然往下执行，如果p2进程还在执行，将会返回True print("p2.is_alive=%s " % p2.is_alive()) # 输出p1和p2进程的别名和pid print("p1.name=%s" % p1.name) print("p1.pid=%s" % p1.pid) print("p2.name=%s" % p2.name) print("p2.pid=%s" % p2.pid) """ join括号中不携带参数，表示父进程在这个位置要等待p1进程执行完成后，再继续执行下面的语句，一般用于进程间的数据同步 如果不写这一句，下面的is_alive判断将会是True， 改成p1.join(1)， 因为p2需要2秒以上才可能执行完成，父进程等待1秒很可能不能让p1完全执行完成，所以下面的print会输出True，即p1仍然在执行 """ p1.join() print("p1.is_alive=%s" % p1.is_alive())
运行结果：
1.4.1.4 进程的创建-Process子类
创建新的进程还能够使用类的方式，可以自定义一个类，继承Process类，每次实例化这个类的时候，就等同于实例化一个进程对象
示例代码：
from multiprocessing import Process import time import os # 继承Process类 class ProcessClass(Process): """ 因为Process类本身也有__init__方法，这个子类相当于重写了这个方法， 但这样就会带来一个问题，我们并没有完全的初始化一个Process类，所以就不能使用从这个类继承的一些方法和属性， 最好的方法就是将继承类本身传递给Process.__init__方法，完成这些初始化操作 """ def __init__(self,interval): Process.__init__(self) self.interval = interval # 重写了Process类的run()方法 def run(self): print("子进程(%s) 开始执行，父进程为（%s）" % (os.getpid(), os.getppid())) t_start = time.time() time.sleep(self.interval) t_stop = time.time() print("(%s)执行结束，耗时%0.2f秒"%(os.getpid(), t_stop-t_start)) if __name__ == "__main__": t_start = time.time() print("当前程序进程(%s)"%os.getpid()) p1 = ProcessClass(2) # 对一个不包含target属性的Process类执行start()方法，就会运行这个类中的run()方法，所以这里会执行p1.run() p1.start() p1.join() t_stop = time.time() print("(%s)执行结束，耗时%0.2f"%(os.getpid(),t_stop-t_start))
运行结果：
1.4.2 进程池：Pool
当需要创建的子进程数量不多时，可以直接利用multiprocessing中的Process动态成生多个进程，但如果是上百甚至上千个目标，手动的去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。使用类Pool可以创建进程池, 然后把各种数据处理任务都提交给进程池.
初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会创建新的进程来执行
Pool([numprocess, initializer, initargs])
说明:
numprocess 是指要创建的线程数. 默认是cpu的核心数.(os.cpu_count()的返回值)
initializer 是每个进程启动时要执行的可调用对象, 默认是None
initargs是传递给initializer的元组参数.
1.4.2.1 multiprocessing.Pool常用函数解析：
apply(func[, args[, kwds]])：使用阻塞方式调用func
在进程池的一个工作进程中执行func函数, args是传给func的元组参数. 注意使用这个方法让多个进程去执行, 他们是同步执行的. 即:多个进程是顺序执行的.func的返回值就是p.apply的返回值.
apply_async(func[, args, kwargs, callback]) ：使用非阻塞方式调用func
（并行执行，堵塞方式必须等待上一个进程退出才能执行下一个进程），args为传递给func的参数列表，kwds为传递给异步的执行func
callback 是可调用对象, 当func执行结束, 则立即调用callback并把func的返回值传递给callback.
func的关键字参数列表；
close()：关闭Pool，使其不再接受新的任务；
terminate()：不管任务是否完成，立即终止；
join()：主进程阻塞，等待子进程的退出， 必须在close或terminate之后使用；
AsyncResult对象(apply_async()的返回值)
apply_async()的返回值是AsyncResult实例. 具有如下方法:
a.get([timeout])
等待返回结果, 结果就是任务函数的返回值.
a.ready()
如果任务函数执行结束返回True
a.successful()
如果任务函数执行结束, 且在执行的过程中没有发生异常则
a.wait([timeout])
等待任务结束, 这个方法与get()的区别就是它没有返回值.
1.4.3 进程间通信-Queue
各个进程是完全独立的, 肯定需要通信, multiprocessing包支持进程间通信(IPC, Inter-Process Communication)有两种方式: 管道(Pipe)和队列(Queue).这两种方式都是使用消息传递实现的.
1.4.3.1 Queue的使用
类Queue用来进程间通信.
Queue([maxsize]) 创建共享的进程队列. maxsize是允许的最大项目数. 如果省略此参数, 则无大小限制.
Queue实例对象的一些常用方法:
q.close()
关闭队列, 防止向队列中加入更多数据
q.empty()如果调用此方法时q为空, 则返回True. 如果有其他进程正在向q中添加或删除数据,则结果是不可靠的.
q.full()如果q已满, 则返回True. 结果也是不可靠的.
q.get([block, timeout])
从队列中读取数据. 如果队列为空, 则此方法会阻塞. block是个布尔值, 用来决定是否阻塞, 默认是True, 表示为空时阻塞. 如果设置为False,则在q为空时抛出异常Queue.Empty
q.put(item[, block, timeout)
向队列中添加数据.
q.qsize()
返回队列中目前项目的数量. 结果也是不可靠的.
示例代码：
from multiprocessing import Queue q=Queue(3) # 初始化一个Queue对象，最多可接收三条put消息 q.put("消息1") q.put("消息2") print(q.full()) # False q.put("消息3") print(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)；
1.4.3.2 进程池中的Queue
如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息：
RuntimeError: Queue objects should only be shared between processes through inheritance.
1.4.4 使用pipe实现IPC
类Pipe([duplex]), 在进程间创建一条管道.
返回一个元组(conn1, conn2), 其中conn1, conn2表示管道两端的Connection对象. 默认情况下, 管道是双向的.
如果duplex设置为False, conn1值能用于接收, 而conn2只能用于发送.
Connection对象具有如下方法:
c.close()关闭连接. 如果c被垃圾收集, 将自动调用此方法
c.poll([timeout])如果连接上的数据可以用, 返回True
c.recv()接收管道中的数据. 如果连接的另一端已经关闭, 再也不存在任何数据, 将引发EOFError异常
c.send(obj)通过连接发送数据. obj是与序列号兼容的任意对象.
二、线程
threading是用来提供在一个进程内实现多线程的编程模块.
前面我们学习了多进程编程.
完成多任务, 也可以在一个进程内使用多个线程. 一个进程至少包括一个线程, 这个线程我们称之为主线程. 在主线程中开启的其他线程我们称之为子线程.
一个进程内的所有线程之间可以直接共享资源, 所以线程间的通信要比进程间通信方便了很多.
python的thread模块是比较底层的模块，python的threading模块是对thread做了一些包装的，可以更加方便的被使用
单线程示例：
import time def say_sorry(): print("亲爱的，我错了，我能吃饭了吗？") time.sleep(1) if __name__ == "__main__": for i in range(5): say_sorry()
多线程示例：
import threading import time def say_sorry(): print("亲爱的，我错了，我能吃饭了吗？") time.sleep(1) if __name__ == "__main__": for i in range(5): t = threading.Thread(target=say_sorry) t.start() #启动线程，即让线程开始执行
说明：
可以明显看出使用了多线程并发的操作，花费时间要短很多
创建好的线程，需要调用
start()方法来启动