python3中的进程-阿里云开发者社区

开发者社区> 任平生78> 正文

python3中的进程

简介: 由于GIL的存在,python中的多线程并不是真正的多线程。 如果想要充分的使用多核CPU的资源,在python中大部分情况需要使用多进程。 在计算机中,进程与进程这之间在内存中是相互独立的,是两块完全不同的内存空间,而且相互之间没有任何联系。
+关注继续查看

由于GIL的存在,python中的多线程并不是真正的多线程。

如果想要充分的使用多核CPU的资源,在python中大部分情况需要使用多进程。

在计算机中,进程与进程这之间在内存中是相互独立的,是两块完全不同的内存空间,而且相互之间没有任何联系。

在线程之中,在全局定义一个变量,所有的线程都是共用的,但是不同的进程之间的数据则不是公有的。

multiprocessing包是python中的多进程管理包。

threading.Thread类似,myltiprocessing模块可以利用multiprocessing.Process对象来创建一个子进程。

multiprocessing的很大一部分用法与threading使用同一套API

Process对象与Thread对象的用法相同,也有start(),run()和join()的方法。

此外multiprocessing包中也有Lock,Event,Smaphore,Condition类,这些对象可以像多线程那样,通过参数传递给各个进程,以实现同步进程。

1.进程的创建:

大家在用chrome浏览器浏览网页的时候,打开任务管理器,会看到chrome的进程会不止一个,那么怎么在在一段py程序里面开辟一个子进程呢??

python中子进程的创建有两种方法:

1.通过Process类调用

import multiprocessing
import time

def func():
    print("hello world------>",time.ctime())
    time.sleep(2)   #让系统休眠2S
    print("func ending------>",time.ctime())

if __name__ == "__main__":
    p1=multiprocessing.Process(target=func,args=()) #实例化一个进程
    p1.start()  #启动进程
    print("ending------>",time.ctime())     #计算程序执行所花费的时间 

这样就创建一个进程,如果电脑的CPU是多核的话,这两个程序就会并行执行。

执行程序,程序最后一句"ending"和"hello world"会同进打印在屏幕上,然后程序休眠2s,又会在屏幕上打印一句"func ending",程序执行结束。

在程序执行期间,打开任务管理器,会看到进程列表中有两个python.exe的进程,等到程序执行完成,这两个python.exe的进程又会消失。
程序执行结果:

ending------> Thu Jul 20 15:56:17 2017
hello world------> Thu Jul 20 15:56:17 2017
func ending------> Thu Jul 20 15:56:19 2017

2.继承Process类调用

from multiprocessing import Process
import time

class MyProcess(Process):   #定义一个类,这个类继承multiprocessing.Process这个类
    def __init__(self,i):
        super(MyProcess,self).__init__()
        self.i=i

    def run(self):
        print("%s hello python------>"%self.i,time.ctime())
        time.sleep(2)

if __name__=="__main__":
    p_list=[]
    for i in range(3):
        p1=MyProcess(i) #实例化进程
        p1.start()      #启动进程
        p_list.append(p1)

    for item in p_list:
        item.join()     #阻塞主进程,全子进程执行完毕再执行主进程

    print("ending------>",time.ctime())     #计算程序执行所花费的时间

利用类的继承,创建了3个进程,这三个进程同时在屏幕在打印自身的编号及一句话,然后程序休眠2s后,又会打印结束话语。

在程序的执行过程中,查看系统进程列表,会看到python解释器的进程编号:

E:\py_code>tasklist | findstr python
python.exe                    5760 Console                    1     11,524 K
python.exe                    3488 Console                    1     11,616 K
python.exe                    6900 Console                    1     11,672 K
python.exe                    4384 Console                    1     11,636 K

程序执行结果:

1 hello python------> Thu Jul 20 16:05:07 2017
2 hello python------> Thu Jul 20 16:05:07 2017
0 hello python------> Thu Jul 20 16:05:07 2017
ending------> Thu Jul 20 16:05:09 2017

2.进程的使用方法:

来看下面的例子:
让系统执行一段范围内的累加和累乘操作,计算CPU执行这两个操作所花的时间。
第一种方式:正常的定义两个函数,然后执行程序。

def func1(x):
    res1=0
    for i in range(x):
        res1 += i   #累加计算的结果
    return res1

def func2(y):
    res2=1
    for i in range(1,y):
        res2 *= i    #累乘计算的结果
    return res2

s1=time.time()
func1(100000000)    #执行累加函数
func2(100000)       #执行累乘函数
s2=time.time()
print("cost time:%s"%(s2-s1))   #计算程序执行所花费的时间 

程序返回结果:

cost time:9.273045301437378

第二种方式,使用程序执行另外两个进程,分别调用系统资源来运算,计算CPU所花费的时间。

from multiprocessing import Process
import time

def func1(x):
    res1=0
    for i in range(x):
        res1 += i
    return res1

def func2(y):
    res2=1
    for i in range(1,y):
        res2 *= i
    return res2

if __name__=="__main__":
    t1=time.time()
    p1=Process(target=func1,args=(100000000,))  #实例化进程p1
    p1.start()  #启动进程p1

    p2=Process(target=func2,args=(100000,))     #实例化进程p2
    p2.start()  #启动进程pp2

    p1.join()
    p2.join()

    print("ending")
    t2=time.time()
    print("cost time:%s"%(t2-t1))       #计算程序运行所花费的时间

执行程序,查看系统的任务管理器,可以看到程序在运行的过程中,生成了三个进程。

E:\py_code>tasklist | findstr python
python.exe                    6520 Console                    1     11,536 K
python.exe                    4340 Console                    1     11,612 K
python.exe                    6200 Console                    1     12,240 K

程序执行结果:

ending
cost time:5.437908697128296

可以看到,第二段代码里面有三个进程(一个主进程和两个子进程p1,p2),

同时在执行这两个函数,所以CPU在执行这两个运行的时候所花的时间会少一些的原因。

3.python中,多进程的优缺点:

优点:
    可以利用多核,以实现并形运算
    
缺点:

    1.浪费的系统资源比较多
    2.进程之间的通信比较困难

4.multiprocessing中的Process类中内置方法及用法:

在系统的提示符下,导入multiprocessing模块,使用:

import multiprocessing

查看这个模块的内置的方法:

help(multiprocessing.Process)
multiprocessing.Process内置方法:
构造方法:
    group               线程组
    target              要执行的方法
    name                进程的名
    args/kwargs         执行过程中要传入的参数 

实例方法:
    is_alive()          测试进程是否在运行
    join([timeout])     阻塞当前上下文环境的进程,直到调用此方法的进程终止或到达指定的timeout
    start()             进程准备就绪,等待CPU调度
    run()               start()调用run方法,如果实例进程未制定传入target时,这start执行默认的run()方法    
    terminate()         不管任务是否完成,立即停止工作进程 

属性:
    deamon              和线程的setDeamon功能一样
    name                进程的名字
    pid(ident)          进程号
    ppid                进程的父进程号

Process内置方法的用法:
代码如下:

from multiprocessing import Process
import os
import time
def info(name):
    print("process name:",name)     #打印当前进程的进程名
    print("parent process:",os.getppid())       #打印当前进程的父进程ID号
    print("process:",os.getpid())   #打印当前进程的进程ID号
    print("---------")
    time.sleep(10)

def foo(name):
    info(name)

if __name__=="__main__":
    info("main process")

    p1=Process(target=info,args=("process1",))
    p1.start()
    p1.join()

    p2=Process(target=foo,args=("process2",))
    p2.start()
    p2.join()

    print("ending")

程序执行过程中,打开系统的任务管理器,查找python的进程可以看到:

E:\py_code>tasklist | findstr python
python.exe                    2424 Console                    1     11,536 K
python.exe                    5360 Console                    1     11,632 K
python.exe                    2532 Console                    1     11,664 K

执行程序,返回结果如下:

process name: main process line
parent process: 628
process: 2424
---------   
process name: process1
parent process: 2424
process: 2532
---------
process name: process2
parent process: 2424
process: 5360
---------
ending

可以看到process1process2的进程名和进程号,这两个进程的父进程号都是一样的,都是主进程的进程号。

5.注意事项

需要注意的是,python的进程之间的切换,耗费的系统资源比线程的切换耗费的资源多得多。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
python3中的进程
由于GIL的存在,python中的多线程并不是真正的多线程。 如果想要充分的使用多核CPU的资源,在python中大部分情况需要使用多进程。 在计算机中,进程与进程这之间在内存中是相互独立的,是两块完全不同的内存空间,而且相互之间没有任何联系。
792 0
python os.startfile python实现双击运行程序 python监控windows程序 监控进程不在时重新启动
用python监控您的window服务 原创作品,允许转载,转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。http://world77.blog.51cto.com/414605/782935     最近比较烦,研发给的pc服务版本在虚拟机上已经开始给客户使用了,服务老是莫名的死翘翘,客户不停的电话给我,搞的我心情很差,于是在一个下午,静下心来,用python写了个简单的监控进程的脚本,当发现进程消失的时候,立即调用服务,开启服务。
1562 0
阿里云服务器端口号设置
阿里云服务器初级使用者可能面临的问题之一. 使用tomcat或者其他服务器软件设置端口号后,比如 一些不是默认的, mysql的 3306, mssql的1433,有时候打不开网页, 原因是没有在ecs安全组去设置这个端口号. 解决: 点击ecs下网络和安全下的安全组 在弹出的安全组中,如果没有就新建安全组,然后点击配置规则 最后如上图点击添加...或快速创建.   have fun!  将编程看作是一门艺术,而不单单是个技术。
4495 0
使用OpenApi弹性释放和设置云服务器ECS释放
云服务器ECS的一个重要特性就是按需创建资源。您可以在业务高峰期按需弹性的自定义规则进行资源创建,在完成业务计算的时候释放资源。本篇将提供几个Tips帮助您更加容易和自动化的完成云服务器的释放和弹性设置。
7764 0
一篇文章搞定Python多进程(全)
公众号:pythonislover 前面写了三篇关于python多线程的文章,大概概况了多线程使用中的方法,文章链接如下: 一篇文章搞懂Python多线程简单实现和GIL - https://mp.weixin.
2931 0
python3,进程间的通信
本文来源于python 3.5版本的官方文档 multiprocessing模块为进程间通信提供了两种方法: 1.进程队列queue The Queue class is a near clone of queue.Queue。
819 0
python中的进程池
1.进程池的概念 python中,进程池内部会维护一个进程序列。当需要时,程序会去进程池中获取一个进程。 如果进程池序列中没有可供使用的进程,那么程序就会等待,直到进程池中有可用进程为止。 2.进程池的内置方法 apply 从进程池里取一个进程并同步执行 apply_async 从进程池里取出一个...
624 0
+关注
123
文章
0
问答
文章排行榜
最热
最新
相关电子书
更多
文娱运维技术
立即下载
《SaaS模式云原生数据仓库应用场景实践》
立即下载
《看见新力量:二》电子书
立即下载