Python多进程

多进程介绍

Python多线程无法利用CPU多核的优势。因此在Python开发中,我们一般使用多进程进行并行开发。multiprocessing是类似于threading模块的包。它支持了本地和远程并发性,可以更充分的利用多核资源。

Process类

要运行一个进程需要创建实例化一个Process对象并且调用该类的start()方法。

`

from multiprocessing import Process

def greet(name):
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()`

Process([group [, target [, name [, args [, kwargs]]]]]),group默认为None,不使用,参数target为调用的对象,name为子进程的名字,args为调用对象的参数元组,kwargs为调用对象的字典。

有关的方法和属性

Process中的方法与threading.Thread中的十分相似。

run():进程启动时运行的方法。

start():启动进程,会调用子进程中的run()方法。

join([timeout]):主线程等待当前线程终止,timeout为可选的超时时间,join只能join住start开启的进程,而不能join住run开启的进程。

terminate():强制终止进程,不会进行任何清理操作,如果创建了子进程,该子进程就成了僵尸进程。如果进程还保存了一个锁那么也将不会被释放,进而导致死锁。

is_alive():判断进程是否在运行,为bool值。

name:进程的名字,它是string类型,没有语义,只是用于标志进程,多进程中允许使用同一个名字。

dameon:必须在start()调用前设置,默认为false,如果设为True,代表当前进程为后台运行的守护进程,当前进程的父进程终止时,它也随之终止,并且设定为True后,不能创建自己的新进程。

pid:进程的id

每个进程还有特有的id号,可以通过os.getpid()得到当前进程的ID号,也可以直接使用p.pid得到ID。

from multiprocessing import Process
import os

def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())#得到父进程的id号
    print('process id:', os.getpid())#得到当前进程的id号

def greet(name):
    info('function greet')
    print('hello', name)

if __name__ == '__main__':
    info('main Process')
    p = Process(target=greet, args=('bob',))
    p.start()
    p.join()

进程间的通信

多进程支持两种进程间通信的方式:队列和管道。

队列

队列具有先进先出的特点,并且它是线程和进程安全的,通过q.put()方法将数据插入到队列中,然后使用q.get()方法将数据取出。

from multiprocessing import Process, Queue

def greet(q):
    q.put("hello")

if __name__ == '__main__':
    q = Queue()
    p = Process(target=f, args=(q,))
    p.start()
    print(q.get())    # 打印hello 
    p.join()

管道

Pipe()函数返回一对双向的连接对象,它们代表管道的两端。每个连接对象有send()和recv()方法。当两个进程或者线程试图同时写入或读取管道的一端时,管道中的数据会被损坏,当然同一时刻使用不同的管道端口不会有损坏的风险。

from multiprocessing import Process, Pipe

def greet(p):
    p.send("hello")
    p.close()

if __name__=='__main__':
    left_p,right_p=Pipe()
    p=Process(target=greet,args=(right_p,))
    p.start()
    print(left_p.recv()) #输出hello
    p.join()

进程间的同步

多进程包含与多线程中等价的同步原语。例如可以使用锁机制确保某一时刻只有一个进程打印到标准输出。

from multiprocessing import Process, Lock

def greet(lock,num):
    lock.acquire()  #获取锁
    print("hello",num)
    lock.release()  #将锁释放

if __name__=='__main__':
    lock=Lock()
    for num in range(5):
        Process(target=greet,args=(lock,num),).start()

进程间分享状态

在进行并发编程时,最好尽量避免使用共享状态,尤其是使用多进程时。但是,如果你确实要使用一些共享的数据,多进程也提供一些方法。

共享内存

数组可以利用Value和Array存储在共享内存映射中。

from multiprocessing import Process, Value, Array

def share(val,arr):
    val.value=1
    for i in range(len(arr)):
        arr[i]=arr[i]+1

if __name__=='__main__':
    val=Value('d',0.0)
    arr=Array('i',range(10))

    p=Process(target=share,args=(val,arr))
    p.start()
    p.join()

    print(val.value)
    print(arr[:])

输出值为:

`1.0
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

`

其中d和i分别代表创建Value和Array中存储的数字类型为double和signed integer。这些共享对象都是线程和进程安全的。

服务器进程

通过Manager()创建一个管理类,它可以控制一个服务器进程,这些服务器进程持有Python对象,并且允许其他进程利用代理来操纵Python对象。

from multiprocessing import Process, Manager
def func(dic,li):
    dic['hello']=1
    dic[1]='Bob'
    dic[2.01]=None
    li.reverse()

if __name__=='__main__':

    manager=Manager() 
    dic=manager.dict()
    li=manager.list(range(5))

    p=Process(target=func,args=(dic,li))
    p.start()
    p.join()
    print(dic)
    print(li)

输出结果为:

{'hello': 1, 1: 'Bob', 2.01: None}
[4, 3, 2, 1, 0]

服务器进程管理比使用共享内存对象更加的灵活,因为它可以支持任意类型的对象。manager也可以通过进程进行共享,只不过比使用共享内存慢。

进程池

进程池中有许多进程,它有方法让进程池中的进程以不同的方式运行任务。 可以创建一个池池,这些进程将执行池类向它提交的任务。
多进程编程并不是进程越多越好,还与CPU核数有关,进程数过多反而会降低效率。

Pool([processes[, initializer[, initargs[, maxtasksperchild]]]])

相关方法

apply(func[, args[, kwds]]):在一个池工作进程中执行func(*args,**kwargs),然后返回结果。需要强调的是:此操作并不会在所有池工作进程中并执行func函数。如果要通过不同参数并发地执行func函数,必须从不同线程调用p.apply()函数或者使用
p.apply_async()

apply_async(func [, args [, kwargs]]):在一个池工作进程中执func(*args,**kwargs),然后返回结果。此方法的结果是AsyncResult类的实例,callback是可调用对象,接收输入参数。当func的结果变为可用时,将理解传递给callback。callback禁止执行任何阻塞操作,否则将接收其他异步操作中的结果。

close():关闭进程池。如果所有操作持续挂起,它们将在工作进程终止前完成。

P.join():等待所有工作进程退出。此方法只能在close()或teminate()之后调用

from multiprocessing import Pool

def sqr(x):
    return x*x

if __name__=='__main__':
    pool=Pool(processes=5) #开启5个工作进程
    result=pool.apply_async(sqr,[10]) #异步计算sqr(10))
    print(result.get(timeout=1)) #输出100
    print(pool.map(sqr,range(5))) #输出[0,1,4.....16]

参考

https://www.cnblogs.com/smallmars/p/7093603.html
http://docspy3zh.readthedocs.io/en/latest/library/multiprocessing.html

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页