一、关于进程锁。

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

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

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

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

#!/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回调函数本身必须接收一个参数,这个参数用来接收上一个函数执行完毕后的返回值。




      本文转自苏浩智 51CTO博客,原文链接:http://blog.51cto.com/suhaozhi/1926096,如需转载请自行联系原作者