Python进程学习

简介:

线程及进程概念可自行学习

 

Unix/Linux操作系统提供了一个fork()系统调用,它非常特殊。普通的函数调用,调用一次,返回一次,但是fork()调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然后,分别在父进程和子进程内返回。

子进程永远返回0,而父进程返回子进程的ID。这样做的理由是,一个父进程可以fork出很多子进程,所以,父进程要记下每个子进程的ID,而子进程只需要调用getppid()就可以拿到父进程的ID。

常用方法:

multiprocessing.cpu_count()    计算当前计算机有几个CPU可用

multiprocessing.active_children()    查看当前还活着的子进程

p.is_alive()    查看当前进程是否存活

p.join()    进程的阻塞,如果join中无参数,则等待进程运行完后继续执行主函数,如果join有timeout参数,则超出timeout时间后继续执行主函数,不等待进程返回结果

p.name()    输出p进程的名字

p.pid()    输出p进程的pid是多少

p.start()    开始p进程,与run()方法相同

Python的os模块封装了常见的系统调用,其中就包括fork,可以在Python程序中轻松创建子进程:

例子:

import os

print 'Process (%s) start...' % os.getpid()

pid = os.fork()

if pid==0:

    print 'I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid())

else:

    print 'I (%s) just created a child process (%s).' % (os.getpid(), pid)

输出:

Process (876) start...

I (876) just created a child process (877).

I am child process (877) and my parent is 876.

 

有了fork调用,一个进程在接到新任务时就可以复制出一个子进程来处理新任务,常见的Apache服务器就是由父进程监听端口,每当有新的http请求时,就fork出子进程来处理新的http请求。

 

multiprocessing

由于Python是跨平台的,自然也应该提供一个跨平台的多进程支持。multiprocessing模块就是跨平台版本的多进程模块。

multiprocessing模块提供了一个Process类来代表一个进程对象,下面的例子演示了启动一个子进程并等待其结束:

例子:

from multiprocessing import Process

import os

 

# 子进程要执行的代码

def run_proc(name):

    print 'Run child process %s (%s)...' % (name, os.getpid())

 

if __name__=='__main__':

    print 'Parent process %s.' % os.getpid()

    p = Process(target=run_proc, args=('test',))

    print 'Process will start.'

    p.start()

    p.join()

    print 'Process end.'

输出:

Parent process 928.

Process will start.

Run child process test (929)...

Process end.

创建子进程时,只需要传入一个执行函数和函数的参数,创建一个Process实例,用start()方法启动,这样创建进程比fork()还要简单。

join()方法可以等待子进程结束后再继续往下运行,通常用于进程间的同步。

例子:

#创建子进程的方法

import time

import multiprocessing

def worker(name,interval):

    print ("{0} start".format(name))

    time.sleep(interval)

    print ("{0} end".format(name))

if __name__ == "__main__":

    print("main start")

    print (multiprocessing.cpu_count())

    #创建子进程,目标是那个函数,传递的参数都有哪些

    p1 = multiprocessing.Process(target=worker, args=("worker1",2))

    p2 = multiprocessing.Process(target=worker, args=("worker2",3))

    p3 = multiprocessing.Process(target=worker, args=("worker3",4))

    #启动进程

    p1.start()

    p2.start()

    p3.start()

    for i in multiprocessing.active_children():

        print ("The PID of {0} is {1}".format(i.name, i.pid))

    print("main end")

输出:

main start

4

The PID of Process-1 is 1588

The PID of Process-3 is 6216

The PID of Process-2 is 5724

main end

worker1 start

worker2 start

worker3 start

worker1 end

worker2 end

worker3 end

Pool

如果要启动大量的子进程,可以用进程池的方式批量创建子进程:

例子:

from multiprocessing import Pool

import os, time, random

 

def long_time_task(name):

    print 'Run task %s (%s)...' % (name, os.getpid())

    start = time.time()

    time.sleep(random.random() * 3)

    end = time.time()

    print 'Task %s runs %0.2f seconds.' % (name, (end - start))

 

if __name__=='__main__':

    print 'Parent process %s.' % os.getpid()

    p = Pool()

    for i in range(5):

        p.apply_async(long_time_task, args=(i,))

    print 'Waiting for all subprocesses done...'

    p.close()

    p.join()

    print 'All subprocesses done.'

输出:

Parent process 669.

Waiting for all subprocesses done...

Run task 0 (671)...

Run task 1 (672)...

Run task 2 (673)...

Run task 3 (674)...

Task 2 runs 0.14 seconds.

Run task 4 (673)...

Task 1 runs 0.27 seconds.

Task 3 runs 0.86 seconds.

Task 0 runs 1.41 seconds.

Task 4 runs 1.91 seconds.

All subprocesses done.

代码解读:

对Pool对象调用join()方法会等待所有子进程执行完毕,调用join()之前必须先调用close(),调用close()之后就不能继续添加新的Process了。

请注意输出的结果,task 0,1,2,3是立刻执行的,而task 4要等待前面某个task完成后才执行,这是因为Pool的默认大小在我的电脑上是4,因此,最多同时执行4个进程。这是Pool有意设计的限制,并不是操作系统的限制。如果改成:

p = Pool(5)

就可以同时跑5个进程。

由于Pool的默认大小是CPU的核数,如果你不幸拥有8核CPU,你要提交至少9个子进程才能看到上面的等待效果。

 

进程间通信

Process之间肯定是需要通信的,操作系统提供了很多机制来实现进程间的通信。Python的multiprocessing模块包装了底层的机制,提供了Queue、Pipes等多种方式来交换数据。

 

我们以Queue为例,在父进程中创建两个子进程,一个往Queue里写数据,一个从Queue里读数据:

例子:

from multiprocessing import Process, Queue

import os, time, random

 

# 写数据进程执行的代码:

def write(q):

    for value in ['A', 'B', 'C']:

        print 'Put %s to queue...' % value

        q.put(value)

        time.sleep(random.random())

 

# 读数据进程执行的代码:

def read(q):

    while True:

        value = q.get(True)

        print 'Get %s from queue.' % value

 

if __name__=='__main__':

    # 父进程创建Queue,并传给各个子进程:

    q = Queue()

    pw = Process(target=write, args=(q,))

    pr = Process(target=read, args=(q,))

    # 启动子进程pw,写入:

    pw.start()

    # 启动子进程pr,读取:

    pr.start()

    # 等待pw结束:

    pw.join()

    # pr进程里是死循环,无法等待其结束,只能强行终止:

    pr.terminate()

输出:

Put A to queue...

Get A from queue.

Put B to queue...

Get B from queue.

Put C to queue...

Get C from queue.

在Unix/Linux下,multiprocessing模块封装了fork()调用,使我们不需要关注fork()的细节。由于Windows没有fork调用,因此,multiprocessing需要“模拟”出fork的效果,父进程所有Python对象都必须通过pickle序列化再传到子进程去,所有,如果multiprocessing在Windows下调用失败了,要先考虑是不是pickle失败了。


多进程锁

例子:

import multiprocessing

import time

def add(number, value, lock):

    #获取锁

    lock.acquire()

    #异常的捕获

    try:

        print ("add{0} number = {1}".format(value, number))

        for i in xrange(1, 6):

            number += value

            time.sleep(1)

            print ("add{0} number = {1}".format(value, number))

    except Exception as e:

        raise e

    finally:

        #释放锁

        lock.release()

 

if __name__ == "__main__":

    #锁的实例化

    lock = multiprocessing.Lock()

    number = 0

    #进程包含进程锁,p1和p2进程分别去抢锁,先抢到的先运行

    p1 = multiprocessing.Process(target=add, args=(number, 1, lock))

    p2 = multiprocessing.Process(target=add, args=(number, 3, lock))

    p1.start()

    p2.start()

    print ("main end")

输出:

main end

add3 number = 0

add3 number = 3

add3 number = 6

add3 number = 9

add3 number = 12

add3 number = 15

add1 number = 0

add1 number = 1

add1 number = 2

add1 number = 3

add1 number = 4

add1 number = 5

例子:

import multiprocessing

import time

def add(number, value, lock):

    #使用with lock写法来自动加锁及释放,与acquire和release相同

    with lock:

        print ("add{0} number = {1}".format(value, number))

        for i in xrange(1, 6):

            number += value

            time.sleep(1)

            print ("add{0} number = {1}".format(value, number))

 

if __name__ == "__main__":

    #锁的实例化

    lock = multiprocessing.Lock()

    number = 0

    #进程包含进程锁,p1和p2进程分别去抢锁,先抢到的先运行

    p1 = multiprocessing.Process(target=add, args=(number, 1, lock))

    p2 = multiprocessing.Process(target=add, args=(number, 3, lock))

    p1.start()

    p2.start()

    print ("main end")

输出:

main end

add1 number = 0

add1 number = 1

add1 number = 2

add1 number = 3

add1 number = 4

add1 number = 5

add3 number = 0

add3 number = 3

add3 number = 6

add3 number = 9

add3 number = 12

add3 number = 15

共享内存

import multiprocessing

import time

def add(number, add_value):

    try:

        print ("add{0} number = {1}".format(add_value, number.value))

        for i in xrange(1, 6):

            number.value += add_value

            time.sleep(1)

            print ("add{0} number = {1}".format(add_value, number.value))

    except Exception as e :

        raise e

if __name__ == "__main__":

    #number共享内存的实例化,number.value才可以使用共享内存操作,分别有value和array

    number = multiprocessing.Value('i', 0)

    p1 = multiprocessing.Process(target=add, args=(number, 1))

    p2 = multiprocessing.Process(target=add, args=(number, 3))

    p1.start()

    p2.start()

    print ("main end")

输出:

main end

add1 number = 0

add3 number = 1

add1 number = 4

add3 number = 5

add1 number = 8

add3 number = 9

add1 number = 12

add3 number = 13

add1 number = 16

add3 number = 17

add1 number = 20

add3 number = 20


多进程manager管理

manager可以接收多种类型的数据,相比较array和value功能更丰富

例子:

import multiprocessing

def worker(d, l):

    l += range(11,16)

    for i in xrange(1,6):

        key = "key {0}".format(i)

        value = "value {0}".format(i)

        d[key] = value

if __name__ == "__main__":

    #实例化manager

    manager = multiprocessing.Manager()

    #接收字典类型的数据

    d = manager.dict()

    #接收列表类型的数据

    l = manager.list()

    p = multiprocessing.Process(target=worker, args=(d, l))

    p.start()

    p.join()

    print (d)

    print (l)

输出:

{'key 1': 'value 1', 'key 2': 'value 2', 'key 3': 'value 3', 'key 4': 'value 4', 'key 5': 'value 5'}

[11, 12, 13, 14, 15]

进程池

与MySQL连接池含义类似,创建连接池后所有进程都从进程池连接,超出进程池数量的进程会排队等待

例子:

import multiprocessing

import time

def fun1(message):

    print ("start {0}".format(message))

    time.sleep(1)

    print ("end {0}".format(message))

if __name__ == "__main__":

    # 实例化进程池

    pool = multiprocessing.Pool(2)

    for i in xrange(1,10):

        message = "number is {0}".format(i)

        # apply_async是将进程池跑满,多进程同时操作

        pool.apply_async(func=fun1,args=(message,))

    pool.close()

    # 等待所有进程关闭,在join前需要close

    pool.join()

输出:

start number is 1

start number is 2

end number is 1

start number is 3

end number is 2

start number is 4

end number is 4

start number is 5

end number is 3

start number is 6

end number is 6

start number is 7

end number is 5

start number is 8

end number is 8

end number is 7

start number is 9

end number is 9

例子:

import multiprocessing

import time

def fun1(message):

    print ("start {0}".format(message))

    time.sleep(1)

    print ("end {0}".format(message))

if __name__ == "__main__":

    # 实例化进程池

    pool = multiprocessing.Pool(2)

    for i in xrange(1,10):

        message = "number is {0}".format(i)

        # apply是单进程,只有一个进程在运行

        pool.apply(func=fun1,args=(message,))

    pool.close()

    # 等待所有进程关闭,在join前需要close

    pool.join()

输出:

start number is 1

end number is 1

start number is 2

end number is 2

start number is 3

end number is 3

start number is 4

end number is 4

start number is 5

end number is 5

start number is 6

end number is 6

start number is 7

end number is 7

start number is 8

end number is 8

start number is 9

end number is 9




本文转自 粗粮面包 51CTO博客,原文链接:http://blog.51cto.com/culiangmianbao/2049218,如需转载请自行联系原作者

相关文章
|
10天前
|
安全 Python
告别低效编程!Python线程与进程并发技术详解,让你的代码飞起来!
【7月更文挑战第9天】Python并发编程提升效率:**理解并发与并行,线程借助`threading`模块处理IO密集型任务,受限于GIL;进程用`multiprocessing`实现并行,绕过GIL限制。示例展示线程和进程创建及同步。选择合适模型,注意线程安全,利用多核,优化性能,实现高效并发编程。
24 3
|
9天前
|
供应链 数据挖掘 Python
后劲真大,我愿称之为学习python的“圣经”
很多小伙伴都在学习Python,但是爱看书的找不到适合自己的,这本书可以完美的解决你的问题,还能帮助到很多需要处理数据,做Excel自动方面的。 学习数据分析的好处众多,无论是对于个人职业发展还是企业的运营决策都具有重要意义。
|
7天前
|
机器学习/深度学习 数据采集 算法
Python实现ISSA融合反向学习与Levy飞行策略的改进麻雀优化算法优化支持向量机回归模型(SVR算法)项目实战
Python实现ISSA融合反向学习与Levy飞行策略的改进麻雀优化算法优化支持向量机回归模型(SVR算法)项目实战
|
4天前
|
消息中间件 安全 数据处理
Python中的并发编程:理解多线程与多进程的区别与应用
在Python编程中,理解并发编程是提高程序性能和响应速度的关键。本文将深入探讨多线程和多进程的区别、适用场景及实际应用,帮助开发者更好地利用Python进行并发编程。
|
7天前
|
机器学习/深度学习 数据采集 算法
Python实现ISSA融合反向学习与Levy飞行策略的改进麻雀优化算法优化支持向量机分类模型(SVC算法)项目实战
Python实现ISSA融合反向学习与Levy飞行策略的改进麻雀优化算法优化支持向量机分类模型(SVC算法)项目实战
|
9天前
|
数据库 数据安全/隐私保护 C++
Python并发编程实战:线程(threading)VS进程(multiprocessing),谁才是并发之王?
【7月更文挑战第10天】Python并发对比:线程轻量级,适合I/O密集型任务,但受GIL限制;进程绕过GIL,擅CPU密集型,但通信成本高。选择取决于应用场景,线程利于数据共享,进程利于多核利用。并发无“王者”,灵活运用方为上策。
|
8天前
|
消息中间件 JSON 自然语言处理
python多进程日志以及分布式日志的实现方式
python日志在多进程环境下的问题 python日志模块logging支持多线程,但是在多进程下写入日志文件容易出现下面的问题: PermissionError: [WinError 32] 另一个程序正在使用此文件,进程无法访问。 也就是日志文件被占用的情况,原因是多个进程的文件handler对日志文件进行操作产生的。
|
10天前
|
安全 API 调度
深度剖析:Python并发编程中的线程与进程,那些你不可不知的使用技巧与限制!
【7月更文挑战第9天】Python并发:线程适合IO密集型任务,利用GIL下的多线程同步,如示例中使用锁。进程适用于CPU密集型,通过multiprocessing模块实现多进程,利用进程间通信如队列。线程受限于GIL,进程间通信成本高。选择取决于任务需求和性能目标。
14 2
|
5天前
|
Unix Linux Python
`subprocess`模块是Python中用于生成新进程、连接到它们的输入/输出/错误管道,并获取它们的返回(退出)代码的模块。
`subprocess`模块是Python中用于生成新进程、连接到它们的输入/输出/错误管道,并获取它们的返回(退出)代码的模块。
|
5天前
|
Python
在Python中,`multiprocessing`模块提供了一种在多个进程之间共享数据和同步的机制。
在Python中,`multiprocessing`模块提供了一种在多个进程之间共享数据和同步的机制。