一、关于进程锁。

其实关于进程锁没啥好讲的了，作用跟线程的互斥锁（又叫全局锁也叫同步锁）作用几乎是一样的。

都是用来给公共资源上锁，进行数据保护的。

当一个进程想去操作一个公共资源，它就可以给公共资源进程“上锁”的操作，其他进程如果也想去访问或者操作这个公共资源，那么其他的进程只能阻塞，等待刚刚的进程把锁释放，下一个进程才可以对这个公共资源进行操作。

下面是个关于进程锁的使用示范：

#!/usr/local/bin/python2.7

# -*- coding:utf-8 -*-

import multiprocessing

def func1(lock_1,name):

    lock_1.acquire()

    print "hello %s" %(name)  #当执行到这句话的时候，就不再是并行了，和线程中锁的概念是一样的。

    lock_1.release()

if __name__ == '__main__':

    lock = multiprocessing.Lock()

    for num in range(10):

        multiprocessing.Process(target=func1,args=(lock,num)).start()


输出结果：

hello 0

hello 1

hello 2

hello 3

hello 4

hello 5

hello 6

hello 7

hello 8

hello 9


！！补充下，其实在进程中，也可以使用RLock递归锁，信号量，event等各种锁，用法基本和多线程是一样的。


二、关于进程池。

什么是进程池呢？

进程池就是程序中维护的一个进程序列，当需要使用进程的时候，就会从进程池中获取一个进程，当进程池中不再有进程的时候，程序就会阻塞，一直等到有新的进程加入到进程池为止。

那么进程池有什么好处？可以看看下面这个例子。

假如说有个函数，这个函数的内容需要被执行100次，才能完成我们想要完成的任务。

我们假定运行一次这个函数要10秒钟，如果使用单进程单线程的模式串行执行，执行这个函数100次要花费1000秒的时间，效率非常低！

那么多线程呢？我们可以同时开100个线程，每个线程去执行一次这个函数，也很快可以执行结束，但是前提是，这个函数所执行的操作必须属于I/O密集型，这样才可以发挥出多线程的高效率，如果这个函数所执行的操作是计算密集型的呢？（如果计算密集型的任务交给多线程去做，反而可能会降低效率，这是因为全局解释器锁的特性造成的）那我们就需要去考虑去开多进程了。

好，那接下来我们用多线程的方式去处理这个问题。

这个函数既然要执行100次，那么我干脆去开100个进程，让这100个函数并行去执行这个函数。

这样确实可以大大提高效率，但是，无论是开100个进程也好，或者说是开100个线程也好，这样做开销实在是太大了！！！同一个进程里面的多个线程还好，数据资源在多个进程之间都是共享的，线程和线程之间每次切换，值需要保存当前的执行状态就可以了，但是线程呢，线程和线程之间的数据都是独立的，多个进程要想实现数据共享，就要给每个进程复制一份数据资源，开100个线程，数据资源就要被复制100份！开销实在太大了！


其实上面的这些方法都不太好，但是可以折中考虑，创建一个线程池。

接下来我们来分析下进程池的好处。

假设说，我们创建了一个进程池，创建这个进程池的时候，指定这个进程池中最多可以容纳10个进程，也就意味着一次的最大并发是10个进程一起去执行这个函数。

接下来，这10个进程都把自己的事情做完了，当然，这10个进程不可能完全是一起执行完毕的（除非你的cpu有十核），肯定有先执行完任务进程。

那么换种说法吧，这10个并发运行的进程中，现在假如有一个进程已经运行完毕，那么这个进程池中还剩下9个进程，我的进程池中现在空出来了一个位置，空出来的这个位置，还可以继续开一个新的进程去工作（只要进程池中有空位，就可以开启新的进程去继续工作。）

所以说，通过以上的例子，可以明确一点，进程池的好处，就是可以维护一个进程工作的最大并发量，比如我们手动设置进程池中最大可以容纳10个进程，那么在程序运行时，运行的进程数量不会高于10个，也不会低于10个，可以一直维持这个最大并发量。

虽然没办法10秒执行100次这个函数，但是，使用了进程池，肯定要比串行执行要快的多！

所以说，进程池是一个折中的解决方案。


下面是进程池的使用示例：

#!/usr/local/bin/python2.7

# -*- coding:utf-8 -*-

import multiprocessing

import os

import time

def func1(value):

    time.sleep(5)

    print "---------->%s" %(value)

    return value+100

def display_pro_info(value):

    print os.getpid()

    print os.getppid()

    print "log:%s" %(value)

pro_pool = multiprocessing.Pool(10) #创建线程池对象,并指定并最大并发量,如果不指定,会按照当前计算机的cpu核数来自动调整.

display_pro_info(1)

print "--------------->"

for i in range(100): #创建100个线程

   # pro_pool.apply_async(func=func1,args=(i,))  #这一步可以暂时理解为往进程池里添加进程，本文后面会对该步骤做详细描述。

    pro_pool.apply_async(func=func1,args=(i,),callback=display_pro_info) #这里使用了callback回调函数，什么是回调函数，本文后面会介绍。

pro_pool.close() #在这需要注意一点，就是使用进程池，一定要先close再join，否则就会报错。先close后join这个顺序是固定的！！

pro_pool.join()  #没有join的话，进程池里的进程是不会运行的。

print "the end!"


下面输出一下这个程序的运行结果：

44720

40833

log:0

--------------->

---------->0

---------->1

---------->3

---------->2

---------->5

---------->9

---------->4

---------->7

---------->6

---------->8

44720

40833

log:100

44720

40833

log:101

44720

40833

log:103

44720

40833

log:102

44720

40833

log:109

44720

40833

log:104

44720

40833

log:107

44720

40833

log:106

44720

40833

log:105

44720

40833

log:108

......

the end！


下面开始对代码进行分析，并且对进程池中一些常用的方法进行讲解：

  1. 首先来说说，在进程池中添加进程的两种模式。

分别是apply（同步执行模式）和apply_async（异步执行模式）。


1.1 apply（同步执行模式）

    这种模式一般情况下没人会去用，如果进程池使用了这种模式，当进程池的第一个进程执行完毕后，才会执行第二个进程，第二个进程执行完毕后，在执行第三个进程....（也就是说这种模式会阻塞主进程！），无法实现并行效果。（不止如此，这种模式还不支持callback回调函数。）

1.2 apply_async （异步执行模式）

    异步的执行模式，才是可以实现并行效果的模式，支持callback回调函数，当一个进程没有执行完毕，没有返回结果，异步执行的模式并不会对主进程进行阻塞！

补充一点！虽然 apply_async是非阻塞的，但其返回结果的get方法却是阻塞的，如使用result.get()会阻塞主进程！


1.3 pro_pool.apply_async(func=func1,args=(i,),callback=display_pro_info) 

        语法和创建多线程多进程没有什么差别，func用于指定一个进程要运行的函数，args用来给函数传参数，callback用来指定回调函数。


  2.关于join,close,terminate。

  2.1 join 主进程阻塞等待子进程运行结束后退出， join方法要在close或terminate之后使用。（换种说法就是，不加join方法，进程池里的进程根本不会执行~）

  2.2 close 关闭进程池，不再接受新的任务

  2.3 terminate 直接结束进程，不再处理没有处理的任务

#其实join和close比较常用。


    3.关于callback函数的一个简单说明。

    在了解回调函数之前，需要注意！！callback函数是由主进程去调用的，并不是子进程！！从刚刚的示例中就可以看出结果！

    某一个函数执行完毕后，某个函数或者动作执行成功后，再去执行的一个函数，并且之前执行成功的那个函数的返回值，会作为参数传给callback函数。

    让回调函数在主进程下调用有什么好处？

      比如现在需要开10个线程去对数据库中的数据进行操作，现在有个需求，就是对数据库内部进行的操作都需要记录一个日志，我们可以把写日志这个函数做为一个回调（callback）函数。

在不使用callback函数之前，如果想去开10个进程去操作数据库，这10个进程是并发执行的，每个进程都去操作数据库后，同时去写一个日志文件，如果不加锁的话很容易造成日志文件的损坏，所以我们可以把写日志的函数去交给主进程去执行，当进程池中的10个进程运行结束后，主线程直接执行一个写日志的操作，这就是我理解的callback函数的用处。

    拿进程池中的callback来举例吧，pro_pool.apply_async(func=func1,args=(i,),callback=display_pro_info)当func1函数内部执行成功后（只要返回值不为假），display_pro_info这个函数就会被作为回调函数去执行（当然执行这个函数的是主进程！），func1的返回值会作为参数传给display_pro_info这个函数。


最后补充一下，使用callback回调函数需要注意的几点。

  1. 在执行回调函数之前的那个函数，必须有一个返回值！这个返回值有两个用途，第一个用途是判断这个函数是否执行成功，执行成功才可以执行callback函数，另一个用途就是这个返回值会作为参数传给回调函数。

  2. callback回调函数本身必须接收一个参数，这个参数用来接收上一个函数执行完毕后的返回值。