‘壹’ 关于python多进程使用(Queue、生产者和消费者)
关于 的生产者和消费者的实现，刚好最近有用到，简单总结记录下：
是系统独立调度核分配系统资源（CPU、内存）的基本单位，进程之间是相互独立的，每启动一个新的进程相当于把数据进行了一次克隆。
python提供了多种方法实现了多进程中间的 （可以修改同一份数据）。
GIL 的全称是 Global Interpreter Lock(全局解释器锁)，来源是 Python 设计之初的考虑，为了数据安全所做的决定。
某个线程想要执行，必须先拿到 GIL，我们可以把 GIL 看作是“通行证”，并且在一个 Python 进程中，GIL 只有一个，这就导致了多线程抢占GIL耗时。这就是为什么在多核CPU上，Python 的多线程效率并不高的根本原因。
所以有必要学习下多进程的使用。
‘贰’ python怎么多进程
需要借用库，来进行多进程，
threading
可以去了解熟悉这个库，这个可以实现多进程并发
‘叁’ python 多进程
基于官方文档：
https://docs.python.org/zh-cn/3/library/multiprocessing.html
日乐购，刚才看到的一个博客，写的都不太对，还是基于官方的比较稳妥
我就是喜欢抄官方的，哈哈
通常我们使用Process实例化一个进程，并调用 他的 start() 方法启动它。
这种方法和 Thread 是一样的。
上图中，我写了 p.join() 所以主进程是 等待 子进程执行完后，才执行 print("运行结束")
否则就是反过来了（这个不一定，看你的语句了，顺序其实是随机的）例如：
主进加个 sleep
所以不加join() ,其实子进程和主进程是各干各的，谁也不等谁。都执行完后，文件运行就结束了
上面我们用了 os.getpid() 和 os.getppid() 获取 当前进程，和父进程的id
下面就讲一下，这两个函数的用法：
os.getpid()
返回当前进程的id
os.getppid()
返回父进程的id。 父进程退出后，unix 返回初始化进程（1）中的一个
windows返回相同的id (可能被其他进程使用了)
这也就解释了，为啥我上面 的程序运行多次， 第一次打印的parentid 都是 14212 了。
而子进程的父级 process id 是调用他的那个进程的 id ： 1940
视频笔记：
多进程：使用大致方法：
参考： 进程通信（pipe和queue）
pool.map （函数可以有return 也可以共享内存或queue） 结果直接是个列表
poll.apply_async() （同map,只不过是一个进程，返回结果用 xx.get() 获得）
报错：
参考 ： https://blog.csdn.net/xiemanR/article/details/71700531
把 pool = Pool() 放到 if name == " main ": 下面初始化搞定。
结果：
这个肯定有解释的
测试多进程计算效果：
进程池运行：
结果：
普通计算：
我们同样传入 1 2 10 三个参数测试：
其实对比下来开始快了一半的；
我们把循环里的数字去掉一个 0；
单进程：
多进程：
两次测试 单进程/进程池 分别为 0.669 和 0.772 几乎成正比的。
问题 二：
视图：
post 视图里面
Music 类：
直接报错：
写在 类里面也 在函数里用 self.pool 调用也不行，也是相同的错误。
最后 把 pool = Pool 直接写在 search 函数里面，奇迹出现了：
前台也能显示搜索的音乐结果了
总结一点，进程这个东西，最好 写在 直接运行的函数里面，而不是 一个函数跳来跳去。因为最后可能 是在子进程的子进程运行的，这是不许的，会报错。
还有一点，多进程运行的函数对象，不能是 lambda 函数。也许lambda 虚拟，在内存？？
使用 pool.map 子进程 函数报错，导致整个 pool 挂了:
参考： https://blog.csdn.net/hedongho/article/details/79139606
主要你要，对函数内部捕获错误，而不能让异常抛出就可以了。
关于map 传多个函数参数
我一开始，就是正常思维，多个参数，搞个元祖，让参数一一对应不就行了：
报错：
参考：
https://blog.csdn.net/qq_15969343/article/details/84672527
普通的 process 当让可以穿多个参数，map 却不知道咋传的。
apply_async 和map 一样，不知道咋传的。
最简单的方法：
使用 starmap 而不是 map
结果：
子进程结束
1.8399453163146973
成功拿到结果了
关于map 和 starmap 不同的地方看源码：
关于apply_async() ,我没找到多参数的方法，大不了用 一个迭代的 starmap 实现。哈哈
关于 上面源码里面有 itertools.starmap
itertools 用法参考：
https://docs.python.org/zh-cn/3/library/itertools.html#itertool-functions
有个问题，多进程最好不要使用全部的 cpu , 因为这样可能影响其他任务，所以 在进程池 添加 process 参数 指定，cpu 个数：
上面就是预留了 一个cpu 干其他事的
后面直接使用 Queue 遇到这个问题：
解决：
Manager().Queue() 代替 Queue()
因为 queue.get() 是堵塞型的，所以可以提前判断是不是 空的，以免堵塞进程。比如下面这样：
使用 queue.empty() 空为True
‘肆’ 如何使用Python实现多进程编程
1.Process
创建进程的类：Process([group[,target[,name[,args[,kwargs]]]]])，target表示调用对象，args表示调用对象的位置参数元组。kwargs表示调用对象的字典。name为别名。group实质上不使用。
方法：is_alive()、join([timeout])、run()、start()、terminate()。其中，Process以start()启动某个进程。
属性：authkey、daemon（要通过start()设置）、exitcode(进程在运行时为None、如果为–N，表示被信号N结束）、name、pid。其中daemon是父进程终止后自动终止，且自己不能产生新进程，必须在start()之前设置。
例1.1：创建函数并将其作为单个进程
importmultiprocessing
importtime
defworker(interval):
n=5
whilen>0:
print("Thetimeis{0}".format(time.ctime()))
time.sleep(interval)
n-=1
if__name__=="__main__":
p=multiprocessing.Process(target=worker,args=(3,))
p.start()
print"p.pid:",p.pid
print"p.name:",p.name
print"p.is_alive:",p.is_alive()
结果
12345678p.pid:8736p.name:Process-1p.is_alive:TrueThetimeisTueApr2120:55:122015ThetimeisTueApr2120:55:152015ThetimeisTueApr2120:55:182015ThetimeisTueApr2120:55:212015ThetimeisTueApr2120:55:242015
例1.2：创建函数并将其作为多个进程
importmultiprocessing
importtime
defworker_1(interval):
print"worker_1"
time.sleep(interval)
print"endworker_1"
defworker_2(interval):
print"worker_2"
time.sleep(interval)
print"endworker_2"
defworker_3(interval):
print"worker_3"
time.sleep(interval)
print"endworker_3"
if__name__=="__main__":
p1=multiprocessing.Process(target=worker_1,args=(2,))
p2=multiprocessing.Process(target=worker_2,args=(3,))
p3=multiprocessing.Process(target=worker_3,args=(4,))
p1.start()
p2.start()
p3.start()
print("ThenumberofCPUis:"+str(multiprocessing.cpu_count()))
forpinmultiprocessing.active_children():
print("childp.name:"+p.name+" p.id"+str(p.pid))
print"END!!!!!!!!!!!!!!!!!"
结果
1234567891011ThenumberofCPUis:4childp.name:Process-3p.id7992childp.name:Process-2p.id4204childp.name:Process-1p.id6380END!!!!!!!!!!!!!!!!!worker_1worker_3worker_2endworker_1endworker_2endworker_3
例1.3：将进程定义为类
importmultiprocessing
importtime
classClockProcess(multiprocessing.Process):
def__init__(self,interval):
multiprocessing.Process.__init__(self)
self.interval=interval
defrun(self):
n=5
whilen>0:
print("thetimeis{0}".format(time.ctime()))
time.sleep(self.interval)
n-=1
if__name__=='__main__':
p=ClockProcess(3)
p.start()
注：进程p调用start()时，自动调用run()
结果
12345thetimeisTueApr2120:31:302015thetimeisTueApr2120:31:332015thetimeisTueApr2120:31:362015thetimeisTueApr2120:31:392015thetimeisTueApr2120:31:422015
‘伍’ Python实现多进程+进度条显示
之前在写繁体字转简体字的时候，由于数据量比较大，所以用了多进程来实现。其实我对多进程/多线程的认识只是了解概念，第一次看到实际的应用是在BDCI-OCR的项目中，作者用多进程进行图像处理。毫无疑问，并行计算能显着地减少运行时间。
那么为什么用多进程实现并行计算（多核任务），不用多线程呢？
引用链接
网上有很多实现多进程的示例，我只记录自己用过的。
这里我用的是pool.apply_async()，是异步非阻塞的方法，可以理解为：不用等待当前进程执行完毕，随时根据系统调度来进行进程切换。当然，还有其他方法，网上有很多资料，我就不赘述了。
从运行结果中可以发现：因为cpu最大核心数是8，所以前8个任务的进程id都不一样，任务9的进程id与任务2的相同，即任务2执行结束后再执行任务9，依此类推。
模拟的事件：共需处理10个任务，每个任务执行时间为5秒（5 * time.sleep(1)）
参考链接
发现：因为我的cpu是8核，所以10个任务的多进程耗时约为 2×单任务耗时 。
在查阅相关资料时发现，多进程在实际使用的时候有 单参数 和 多参数 之分，那么多参数和单参数的优缺点分别是什么呢？
‘陆’ Python多进程运行——Multiprocessing基础教程2
上篇文章简单介绍了multiprocessing模块，本文将要介绍进程之间的数据共享和信息传递的概念。
在多进程处理中，所有新创建的进程都会有这两个特点：独立运行，有自己的内存空间。
我们来举个例子展示一下：
这个程序的输出结果是：
在上面的程序中我们尝试在两个地方打印全局列表result的内容：
我们再用一张图来帮助理解记忆不同进程间的数据关系：
如果程序需要在不同的进程之间共享一些数据的话，该怎么做呢？不用担心，multiprocessing模块提供了Array对象和Value对象，用来在进程之间共享数据。
所谓Array对象和Value对象分别是指从共享内存中分配的ctypes数组和对象。我们直接来看一个例子，展示如何用Array对象和Value对象在进程之间共享数据：
程序输出的结果如下：
成功了！主程序和p1进程输出了同样的结果，说明程序中确实完成了不同进程间的数据共享。那么我们来详细看一下上面的程序做了什么：
在主程序中我们首先创建了一个Array对象：
向这个对象输入的第一个参数是数据类型：i表示整数，d代表浮点数。第二个参数是数组的大小，在这个例子中我们创建了包含4个元素的数组。
类似的，我们创建了一个Value对象：
我们只对Value对象输入了一个参数，那就是数据类型，与上述的方法一致。当然，我们还可以对其指定一个初始值（比如10），就像这样：
随后，我们在创建进程对象时，将刚创建好的两个对象：result和square_sum作为参数输入给进程：
在函数中result元素通过索引进行数组赋值，square_sum通过 value 属性进行赋值。
注意：为了完整打印result数组的结果，需要使用 result[:] 进行打印，而square_sum也需要使用 value 属性进行打印：
每当python程序启动时，同时也会启动一个服务器进程。随后，只要我们需要生成一个新进程，父进程就会连接到服务器并请求它派生一个新进程。这个服务器进程可以保存Python对象，并允许其他进程使用代理来操作它们。
multiprocessing模块提供了能够控制服务器进程的Manager类。所以，Manager类也提供了一种创建可以在不同流程之间共享的数据的方法。
服务器进程管理器比使用共享内存对象更灵活，因为它们可以支持任意对象类型，如列表、字典、队列、值、数组等。此外，单个管理器可以由网络上不同计算机上的进程共享。
但是，服务器进程管理器的速度比使用共享内存要慢。
让我们来看一个例子：
这个程序的输出结果是：
我们来理解一下这个程序做了什么：首先我们创建了一个manager对象
在with语句下的所有行，都是在manager对象的范围内的。接下来我们使用这个manager对象创建了列表（类似的，我们还可以用 manager.dict() 创建字典）。
最后我们创建了进程p1（用于在records列表中插入一条新的record）和p2（将records打印出来），并将records作为参数进行传递。
服务器进程的概念再次用下图总结一下：
为了能使多个流程能够正常工作，常常需要在它们之间进行一些通信，以便能够划分工作并汇总最后的结果。multiprocessing模块支持进程之间的两种通信通道：Queue和Pipe。
使用队列来回处理多进程之间的通信是一种比较简单的方法。任何Python对象都可以使用队列进行传递。我们来看一个例子：
上面这个程序的输出结果是：
我们来看一下上面这个程序到底做了什么。首先我们创建了一个Queue对象：
然后，将这个空的Queue对象输入square_list函数。该函数会将列表中的数平方，再使用 put() 方法放入队列中：
随后使用 get() 方法，将q打印出来，直至q重新称为一个空的Queue对象：
我们还是用一张图来帮助理解记忆：
一个Pipe对象只能有两个端点。因此，当进程只需要双向通信时，它会比Queue对象更好用。
multiprocessing模块提供了 Pipe() 函数，该函数返回由管道连接的一对连接对象。 Pipe() 返回的两个连接对象分别表示管道的两端。每个连接对象都有 send() 和 recv() 方法。
我们来看一个例子：
上面这个程序的输出结果是：
我们还是来看一下这个程序到底做了什么。首先创建了一个Pipe对象：
与上文说的一样，该对象返回了一对管道两端的两个连接对象。然后使用 send() 方法和 recv() 方法进行信息的传递。就这么简单。在上面的程序中，我们从一端向另一端发送一串消息。在另一端，我们收到消息，并在收到END消息时退出。
要注意的是，如果两个进程(或线程)同时尝试从管道的同一端读取或写入管道中的数据，则管道中的数据可能会损坏。不过不同的进程同时使用管道的两端是没有问题的。还要注意，Queue对象在进程之间进行了适当的同步，但代价是增加了计算复杂度。因此，Queue对象对于线程和进程是相对安全的。
最后我们还是用一张图来示意：
Python的multiprocessing模块还剩最后一篇文章：多进程的同步与池化
敬请期待啦！
‘柒’ Python入门系列（十二）——GUI+多进程
话说，python做图形界面并不明智，效率并不高。但在某些特殊需求下还是需要我们去使用，所以python拥有多个第三方库用以实现GUI，本章我们使用python基本模块tkinter进行学习，因为需求并不大，所以不做太多拓展。
继续改写上一章的IP查询系统（= =，要玩烂了），首先略改下IpWhere.py以备调用~
然后使用tkinter模块进行图形界面的实现，调用预编译的IpWhere模块 ：
额，太丑了，但基本实现我们小小的需求，在以后的py学习中，我们再涉及其他的第三方模块，此处就当是入门了解吧。
十分抱歉把这么重要的内容放在最后，要不是大佬指点，此次学习可能就要错过多进程的问题了。
Unix系统提供了forx，python可借助os模块调用，从而实现多进程，然而windows系统并不具备，所以我们选择python内置的multiprocessing多进程模块进行学习。
首先我们借助直接调用多进程来改写下我们在多线程章节用到的例子！
显然，这么写实在太蠢了，如果我们的任务量巨大，这并不合适。所以我们引入了进程池的概念，使用进程池进行改写：
在此，我们可以看到所有进程是并发执行的，同样，我们在多线程章节就讲过，主进程的结束意味着程序退出，所以我们需要借助join()方法堵塞进程。
我们知道线程共享内存空间，而进程的内存是独立的，同一个进程的线程之间可以直接交流，也就带来了线程同步的苦恼，这个我们在多线程章节已经讲过了；而两个进程想通信，则必须通过一个中间代理来实现，即我们接下来的内容：进程间通信。
进程之间肯定是需要通信的，操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制，提供了Queue、Pipes等多种方式来交换数据。我们接下来就以Queue的方式进行学习。
Queue.Queue是进程内非阻塞队列，multiprocess.Queue是跨进程通信队列，前者是各自私有，后者是各子进程共有。
还有一个在后者基础上进行封装的multiprocess.Manager.Queue()方法，如果要使用Pool创建进程，就需要使用multiprocessing.Manager()中的Queue()，而不是multiprocessing.Queue()，否则会得到一条如下的错误信息： RuntimeError: Queue objects should only be shared between processes through inheritance.
接下来我们就借助进程池来进行多进程操作的改写，感谢大佬一路辅导。
我们可以看到两个子线程先执行，然后一个子线程单独执行，此处有意而为之，让大家更清晰的了解队列的使用。期间有一处我们放弃使用jion()方法堵塞，而是自己写了个循环堵塞，大家根据自己习惯来就好。
话说，真的没人吐槽么？上面的例子从需求上来讲，完全就不需要多线程好不好！emmmm，我们来点实力拓展，写一个有智商的多线程脚本，顺便结合上一节的web来一个综合篇，随便找个现实需求吧！
emmm，比如我们来到当当网买书，搜一下我们想要的书籍，发现！！太多了！！真J2乱！！看不过来！！不想翻页！！直接告诉我哪个便宜、哪个牛逼好不好！！
简单看下这个url：
http://search.dangdang.com/?key=渗透测试&ddsale=1&page_index=2
其中ddsale参数代表当当自营，page_index代表页数，key代表搜索内容，我们本次的变量只有页数。
所以我们构造请求的url为:
'http://search.dangdang.com/?key=渗透测试&ddsale=1&page_index='+str(page)
如果修改的内容不使用str字符串转化，会收到如下报错：
TypeError: can only concatenate str (not "int") to str
然后我们看一下页面内容的分布情况，本次我们关心卖什么书，卖多少钱？
对应的编写我们的正则匹配规则，当然了，有更简便的第三方库可以帮我们处理，但为了更好的形成流程性认识，我们这里依然使用正则。
我们对应我们需要的书籍名称和当前价格匹配如下：
<a title=" (.*?)" ddclick=
<span class="search_now_price">¥(.*?)</span>
那么，思路理清了，我们就开始使用多线程来写我们的小系统~
然后我们去查看一下我们的结果文件~
现在这个小系统具备的功能就是根据用户需要选择要检索的书籍，然后整理下名称和价格，开了10个线程，如果小伙伴pc给力的话可以继续加。简单的异常处理机制和界面交互，基本满足日常所需。
‘捌’ python 多进程
os.fork()指令会创建另外一个进程，他的输出源也是你的python command line或者其他IDE。所以你会看见2个提示符。另外，IDE要处理那么多输出源，当然会很卡。还有，你连打下3次这个命令，相当于对三个进程都进行了下达指令，所以这时候你的进程数目为8(看不懂的建议看小学数学)。你的各个进程的输出会类似于打架，所以窗口会变得很慢。
建议：用pid来区分各个进程(os.fork()在父进程会返回pid，子进程会返回0)，例如：
import os
import time
pid=os.fork()
if pid==0:
time.sleep(0.1);
print "Child."
else:
print "The child's pid is:"+str(pid)
//end
以上代码中子进程我给他暂停0.1秒来防止与父进程的输出“打架”，当然有更好的解决方法，由于字数限制不打出来了，具体就是锁住输出源，通过之后再解锁，可以网络。
点赞、采纳、转发，素质三连，友谊你我他！
‘玖’ Python多进程multiprocessing模块介绍
multiprocessing 是一个支持使用与 threading 模块类似的 API 来产生进程的包。 multiprocessing 包同时提供了本地和远程并发操作，通过使用子进程而非线程有效地绕过了 全局解释器锁。 因此，multiprocessing 模块允许程序员充分利用给定机器上的多个处理器。 它在 Unix 和 Windows 上均可运行。
1、multiprocessing.Process(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)
2、相关方法
输出结果如下：
Pool提供了一种快捷的方法，赋予函数并行化处理一系列输入值的能力，可以将输入数据分配给不同进程处理（数据并行）。下面的例子演示了在模块中定义此类函数的常见做法，以便子进程可以成功导入该模块。这个数据并行的基本例子使用了 Pool 。
将在标准输出中打印
其中：
（1）p.apply(func [, args [, kwargs]]):在一个池工作进程中执行func( args, kwargs),然后返回结果。需要强调的是：此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数，必须从不同线程调用p.apply()函数或者使用p.apply_async()
（2）p.apply_async(func [, args [, kwargs]]):在一个池工作进程中执行func( args,**kwargs),然后返回结果。此方法的结果是 AsyncResult类的实例，callback是可调用对象，接收输入参数。当func的结果变为可用时，将理解传递给callback。callback禁止执行任何阻塞操作，否则将接收其他异步操作中的结果。多进程并发！
（3）p.close():关闭进程池，防止进一步操作。如果所有操作持续挂起，它们将在工作进程终止前完成
（4）p.jion():等待所有工作进程退出。此方法只能在close（）或teminate()之后调用