首页 / PYTHON / Python中的多进程

Python中的多进程

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Python中的多进程，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含10602字，纯文字阅读大概需要16分钟。

内容图文

由于cPython的gill，多线程未必是CPU密集型程序的好的选择。

多线程可以完全独立的进程环境中运行程序，可以充分利用多处理器。

但是进程本身的隔离带来的数据不共享也是一种问题，线程比进程轻量级。

1、Multiprocessing

        

import multiprocessing

import datetime


def calc(i):

    sum = 0

    for _ in range(10000000):

        sum += 1

    print(i,sum)


if __name__ == ‘__main__‘:

    start = datetime.datetime.now()


    ps =[]

    for i in range(5):

        p = multiprocessing.Process(target=calc,args=(i,),name=‘calc-{}‘.format(i))


        ps.append(p)

        p.start()


    for p in ps:

        p.join()


    delta = (datetime.datetime.now()-start).total_seconds()

    print(delta)

    print(‘end==‘)

0 10000000

1 10000000

2 10000000

3 10000000

4 10000000

2.738819

end==

多进程，是真的并行。

名称	说明
Pid	进程id
Exitcode	进程的退出状态码
Terminate()	终止指定的进程

进程间同步：同步提供了和线程同步一样的类，使用的方法一样，使用效果也类似。

不过，进程间代价要高于线程间，而且底层实现是不同的，只不过Python屏蔽了这些不同的地方，让用户简单使用多进程。

Multiprocessing还提供了共享内存，服务器进程来共享数据，还提供了queue队列，pipe管道用于进程间通信。

通信方式不同：

多进程就是启动多个解释器进程，进程间通信必须序列化和反序列化。

数据的线程安全性问题。由于每个进程之间没有实现度贤臣，gil可以说没有什么用了。

2、进程池

Multiprocessing。Pool是进程池类；

名称	说明
Apply（self，func，args=（），kwds={}）	阻塞执行，导致主进程执行其他子进程一个个执行
Apply_async（self，func，args=（），kwargs={}，callback=None，error_callback=None）	与apply方法用法一直，非阻塞执行，得到结果后会执行回调
Close（）	关闭池，池不能再接受新的任务
Terminate()	结束工作进程，不在处理为处理的任务
Join()	主进程阻塞等待子进程的退出，join方法要在close或terminate之后使用

3、多进程、多线程的选择

CPU密集型：cPython中使用到了gill，多线程的时候锁相互竞争，且多核优势不能发挥，Python多进程效率更高。

IO密集型：适合多线程，可以减少多进程之间的IO序列化开销，且在IO等待的时候，切换到其他线程继续执行，效率不错。

4、应用场景

请求/应答模型：web应用中常见的处理模型。

Master启动多个worker工作进程，一般和CPU数目相同。发挥多核优势。

Worker工作进程中，往往需要操作网络IO和磁盘IO，启动多线程，提高高并发处理能力，worker处理用户的请求，往往需要等待数据，处理完请求还需要通过网络IO响应返回，这个就是nginx工作模式。

、concurrent包

1、concurrent.futures

异步并行任务编程模块，提供一个高级的异步可执行的便利接口。

提供了两个池执行器

Threadpoolexecutor异步调用的线程池的executor

Processpoolexecutor异步调用的进程池的executor。

2、threadpoolexecutor对象

首先需要定义一个池的执行器对象，executor类子类对象。

方法	含义
Threadpoolexecutor（man_worker=1）	池中至多创建max_wokers个线程的池来同时异步执行，返回exector实例
Submit（fn，args，*kwargs）	提交执行的函数及其参数，返回future实例
Shutdown（wait=True）	清理池

Future类

方法	含义
Done（）	如果调用被成功的取消或者执行完成，返回true
Cancelled（）	如果调用被成功的取消，返回true
Running（）	如果正在运行且不能被取消，返回true
Cancel（）	尝试取消调用，如果已经执行且不能取消返回False，否则返回true
Result（timeout=none）	取返回的结果，timeout为none，一直等待返回，timeout设置到期，抛出concurrent.futures.timeouterror异常
Exception（timeout=none）	取返回的结果，timeout为none，一直等待返回，timeout设置到期，抛出concurrent.futures.timeouterror异常

import threading

from concurrent import futures

import logging

import time



FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘

logging.basicConfig(format=FORMAT,level=logging.INFO)


def worker(n):

    logging.info(‘start to work{]‘.format(n))

    time.sleep(4)

    logging.info(‘stop{}‘.format(n))



exector = futures.ThreadPoolExecutor(max_workers=3)

fs = []

for i in range(3):

    futures = exector.submit(worker,i)

    fs.append(futures)


for i in range(3,6):

    futures = exector.submit(worker,i)

    fs.append(futures)


while True:

    time.sleep(5)

    logging.info(threading.enumerate())


    flag = True

    for f in fs:

        logging.info(f.done())

        flag = flag and f.done()

    print(‘-‘*30)


    if flag:

        exector.shutdown()

        logging.info(threading.enumerate())

        break

------------------------------

2018-06-13 09:57:35,049 MainThread 8376 [<_MainThread(MainThread, started 8376)>, <Thread(Thread-1, started daemon 7480)>, <Thread(Thread-3, started daemon 7368)>, <Thread(Thread-2, started daemon 7464)>]

2018-06-13 09:57:35,049 MainThread 8376 True

2018-06-13 09:57:35,050 MainThread 8376 True

2018-06-13 09:57:35,051 MainThread 8376 True

2018-06-13 09:57:35,051 MainThread 8376 [<_MainThread(MainThread, started 8376)>]

3、processpoolexector对象

import threading

from concurrent import futures

import logging

import time



FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘

logging.basicConfig(format=FORMAT,level=logging.INFO)


def worker(n):

    logging.info(‘start to work{]‘.format(n))

    time.sleep(4)

    logging.info(‘stop{}‘.format(n))



if __name__ == ‘__main__‘:

    exector = futures.ThreadPoolExecutor(max_workers=3)

    fs = []

    for i in range(3):

        futures = exector.submit(worker,i)

        fs.append(futures)


    for i in range(3,6):

        futures = exector.submit(worker,i)

        fs.append(futures)


    while True:

        time.sleep(5)

        logging.info(threading.enumerate())


        flag = True

        for f in fs:

            logging.info(f.done())

            flag = flag and f.done()

        print(‘-‘*30)


        if flag:

            exector.shutdown()

            logging.info(threading.enumerate())

            break

------------------------------

2018-06-13 10:01:18,076 MainThread 6436 [<Thread(Thread-3, started daemon 4188)>, <Thread(Thread-1, started daemon 7284)>, <_MainThread(MainThread, started 6436)>, <Thread(Thread-2, started daemon 6164)>]

2018-06-13 10:01:18,076 MainThread 6436 True

2018-06-13 10:01:18,077 MainThread 6436 True

2018-06-13 10:01:18,078 MainThread 6436 [<_MainThread(MainThread, started 6436)>]

进程代码的执行过程中，必须要加上if __name__ == ‘__main__’

4、支持上下文管理的调用

Concurrent.futures.processpoolexecutor继承自concurrent.futures.base.executor,而父类有__enter__、__exit__、方法，支持上下文管理，可以使用with语句。

__exit__方法本质上还是调用shutdown（wait=True），就会一直阻塞到所有运行的任务完成。

import threading

from concurrent import futures

import logging

import time



FORMAT = ‘%(asctime)s %(threadName)s %(thread)d %(message)s‘

logging.basicConfig(format=FORMAT,level=logging.INFO)


def worker(n):

    logging.info(‘start to work{}‘.format(n))

    time.sleep(5)

    logging.info(‘stop{}‘.format(n))

    return n + 100


if __name__ == ‘__main__‘:

    executor = futures.ProcessPoolExecutor(max_workers=3)


    with executor:

        fs = []

        for i in range(3):

            futures = executor.submit(worker,i)

            fs.append(futures)


        for i in range(3,6):

            futures = executor.submit(worker,i)

            fs.append(futures)


        while True:

            time.sleep(2)

            logging.info(threading.enumerate())


            flag = True

            for f in fs:

                logging.info(f.done())

                flag = flag and f.done()

                if f.done():

                    logging.info(‘result={}‘.format(f.result()))


            print(‘-‘*30)

            if flag:break


    logging.info(‘-------end--------‘)

    logging.info(threading.enumerate())

2018-06-13 10:18:35,744 MainThread 5468 start to work0

2018-06-13 10:18:35,751 MainThread 7936 start to work1

2018-06-13 10:18:35,763 MainThread 7020 start to work2

2018-06-13 10:18:37,528 MainThread 7976 [<_MainThread(MainThread, started 7976)>, <Thread(QueueFeederThread, started daemon 8136)>, <Thread(Thread-1, started daemon 3932)>]

2018-06-13 10:18:37,528 MainThread 7976 False

2018-06-13 10:18:37,529 MainThread 7976 False

------------------------------

2018-06-13 10:18:39,530 MainThread 7976 [<_MainThread(MainThread, started 7976)>, <Thread(QueueFeederThread, started daemon 8136)>, <Thread(Thread-1, started daemon 3932)>]

2018-06-13 10:18:39,530 MainThread 7976 False

2018-06-13 10:18:39,531 MainThread 7976 False

2018-06-13 10:18:39,532 MainThread 7976 False

2018-06-13 10:18:40,744 MainThread 5468 stop0

2018-06-13 10:18:40,745 MainThread 5468 start to work3

2018-06-13 10:18:40,751 MainThread 7936 stop1

2018-06-13 10:18:40,753 MainThread 7936 start to work4

2018-06-13 10:18:40,764 MainThread 7020 stop2

2018-06-13 10:18:40,764 MainThread 7020 start to work5

2018-06-13 10:18:41,533 MainThread 7976 [<_MainThread(MainThread, started 7976)>, <Thread(QueueFeederThread, started daemon 8136)>, <Thread(Thread-1, started daemon 3932)>]

2018-06-13 10:18:41,533 MainThread 7976 True

2018-06-13 10:18:41,534 MainThread 7976 result=100

2018-06-13 10:18:41,534 MainThread 7976 True

2018-06-13 10:18:41,535 MainThread 7976 result=101

2018-06-13 10:18:41,535 MainThread 7976 True

2018-06-13 10:18:41,536 MainThread 7976 result=102

2018-06-13 10:18:41,536 MainThread 7976 False

2018-06-13 10:18:41,537 MainThread 7976 False

------------------------------

2018-06-13 10:18:43,537 MainThread 7976 [<_MainThread(MainThread, started 7976)>, <Thread(QueueFeederThread, started daemon 8136)>, <Thread(Thread-1, started daemon 3932)>]

2018-06-13 10:18:43,537 MainThread 7976 True

2018-06-13 10:18:43,537 MainThread 7976 result=100

2018-06-13 10:18:43,538 MainThread 7976 True

2018-06-13 10:18:43,538 MainThread 7976 result=101

2018-06-13 10:18:43,538 MainThread 7976 True

2018-06-13 10:18:43,538 MainThread 7976 result=102

2018-06-13 10:18:43,538 MainThread 7976 False

2018-06-13 10:18:43,539 MainThread 7976 False

------------------------------

2018-06-13 10:18:45,540 MainThread 7976 [<_MainThread(MainThread, started 7976)>, <Thread(QueueFeederThread, started daemon 8136)>, <Thread(Thread-1, started daemon 3932)>]

2018-06-13 10:18:45,540 MainThread 7976 True

2018-06-13 10:18:45,540 MainThread 7976 result=100

2018-06-13 10:18:45,541 MainThread 7976 True

2018-06-13 10:18:45,541 MainThread 7976 result=101

2018-06-13 10:18:45,541 MainThread 7976 True

2018-06-13 10:18:45,541 MainThread 7976 result=102

2018-06-13 10:18:45,542 MainThread 7976 False

2018-06-13 10:18:45,746 MainThread 5468 stop3

2018-06-13 10:18:45,754 MainThread 7936 stop4

2018-06-13 10:18:45,765 MainThread 7020 stop5

------------------------------

2018-06-13 10:18:47,542 MainThread 7976 [<_MainThread(MainThread, started 7976)>, <Thread(QueueFeederThread, started daemon 8136)>, <Thread(Thread-1, started daemon 3932)>]

2018-06-13 10:18:47,542 MainThread 7976 True

2018-06-13 10:18:47,542 MainThread 7976 result=100

2018-06-13 10:18:47,543 MainThread 7976 True

2018-06-13 10:18:47,543 MainThread 7976 result=101

2018-06-13 10:18:47,544 MainThread 7976 True

2018-06-13 10:18:47,544 MainThread 7976 result=102

2018-06-13 10:18:47,544 MainThread 7976 True

2018-06-13 10:18:47,544 MainThread 7976 result=103

2018-06-13 10:18:47,544 MainThread 7976 True

2018-06-13 10:18:47,545 MainThread 7976 result=104

2018-06-13 10:18:47,545 MainThread 7976 True

2018-06-13 10:18:47,545 MainThread 7976 result=105

2018-06-13 10:18:47,587 MainThread 7976 -------end--------

2018-06-13 10:18:47,587 MainThread 7976 [<_MainThread(MainThread, started 7976)>]

总结，统一了线程池、进程池调用，简化了编程。

无法设置线程名称。

原文：https://www.cnblogs.com/wangchunli-blogs/p/9949898.html

内容总结

以上是互联网集市为您收集整理的Python中的多进程全部内容，希望文章能够帮你解决Python中的多进程所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1191613.html

来源：【匿名】

【上一篇】Python元组【下一篇】浅谈PHP运行Python脚本的方法

更多 ►

【Python中的多进程】教程文章相关的互联网学习教程文章

python_并发编程——多进程的第二种启动方式【代码】【图】

1.多进程的第二种启动方式import os from multiprocessing import Process # 创建一个自定义类，继承Process类class MyProcess(Process):# 必须实现一个run方法，run方法中是子进程中执行的代码def run(self):print(‘子进程：‘,os.getpid())if__name__ == ‘__main__‘:print(‘主进程‘,os.getpid())p1 = MyProcess()p1.start()p2 = MyProcess()p2.start()结果： 2.进程号和进程名import os from multiprocessing import Proc...

Python一篇学会多进程【代码】【图】

阅读目录1. Process2. Lock3. Semaphore4. Event5. Queue6. Pipe7. Pool序. multiprocessing python 中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing，只需要定义一个函数，Python会完成其他所有事情。借助这个包，可以轻松完成从单进程到并发执行的转换。multiprocessing支持子进程、通信和共享数据、执行不同形式的同...

PYTHON自动化Day10-经典类和新式类的区别、重写父类方法、多线程、多进程、数据驱动框架的编写【代码】

一.重写父类方法、经典类和新式类在python2中的区别：#两种情况： #1.父类的方法子类中完全不需要，子类重新写 #2.父类有这个方法，但功能不够完善，子类想要在父类这个方法的基础上再添加一些新功能class ZLL():def smile(self):print(‘哈哈哈‘)class Xz(ZLL): #继承这个父类def smile(self): #重写父类的方法　　　　　#如果想要在子类中执行父类的smile方法# ZLL().smile() #调用父类，注意ZLL后面有（），因为调用的是实...

Python中的多进程【代码】

由于cPython的gill，多线程未必是CPU密集型程序的好的选择。多线程可以完全独立的进程环境中运行程序，可以充分利用多处理器。但是进程本身的隔离带来的数据不共享也是一种问题，线程比进程轻量级。 1、Multiprocessing import multiprocessing import datetime def calc(i): sum = 0 for _ in range(10000000): sum += 1 print(i,sum) if __name__ == ‘__main__‘: start = datetime.datetime.now() ...

也说性能测试，顺便说python的多进程嵌套多线程【代码】

最近需要一个web系统进行接口性能测试，这里顺便说一下性能测试的步骤吧，大概如下　　一、分析接口频率　　根据系统的复杂程度，接口的数量有多有少，应该优先对那些频率高，数据库操作频繁的接口进行性能测试，所以先和开发根据业务情况，找到频率最高的几个接口。　　二、找到合适的测试工具　　性能测试工具简直数不胜数，最著名莫过于loadrunner，因为它支持windows，呵呵呵，这也是我刚毕业时用的工具（当然是盗版了。。。）...

python并发编程之多进程【代码】

一.multiprocessing模块　　multiprocessing模块用来开启子进程，并在子进程中执行我们定制的任务（比如函数），该模块与多线程模块threading的编程接口类似。　 multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。　　注意：与线程不同，进程没有任何共享的状态，进程修改的数据，仅限于进程内。二.Process类　由该类实例化得到的对象，表示一个子进程...

cpython多进程【代码】

四同步\异步and阻塞\非阻塞（重点）同步：#所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不会返回。按照这个定义，其实绝大多数函数都是同步调用。但是一般而言，我们在说同步、异步的时候，特指那些需要其他部件协作或者需要一定时间完成的任务。 #举例： #1. multiprocessing.Pool下的apply #发起同步调用后，就在原地等着任务结束，根本不考虑任务是在计算还是在io阻塞，总之就是一股脑地等任务结束 #2. ...

python 多进程【代码】

multiprocessing 模块介绍python中的多线程无法利用多核优势,如果想要充分的使用多核cpu的资源,os.cpu_count可以查看逻辑cpu数,在python中大部分情况需要使用多进程,python提供了multiprocessingmuliprocessing模块用来开启子进程,并在子进程中执行我们制定的任务(比如函数),这个模块与多线程模块threading编程接口类似multiprocessing模块的功能众多,支持子进程,通信和共享数据,执行不同形式的同步,提供了Process,Queue,Pipe,Lock...

python 并发编程多进程 Process对象的其他属性方法 join 方法【代码】

一 Process对象的join方法在主进程运行过程中如果想并发地执行其他的任务，我们可以开启子进程，此时主进程的任务与子进程的任务分两种情况情况一：在主进程的任务与子进程的任务彼此独立的情况下，主进程的任务先执行完毕后，主进程还需要等待子进程执行完毕，然后统一回收资源。这种是没有join方法情况二：如果主进程的任务在执行到某一个阶段时，需要等待子进程执行完毕后才能继续执行，就需要有一种机制能够让主进程检测子进...

Python有了asyncio和aiohttp在爬虫这类型IO任务中多线程/多进程还有存在的必要吗？【代码】

最近正在学习Python中的异步编程，看了一些博客后做了一些小测验：对比asyncio+aiohttp的爬虫和asyncio+aiohttp+concurrent.futures(线程池/进程池)在效率中的差异，注释：在爬虫中我几乎没有使用任何计算性任务，为了探测异步的性能，全部都只是做了网络IO请求，就是说aiohttp把网页get完就程序就done了。结果发现前者的效率比后者还要高。我询问了另外一位博主，(提供代码的博主没回我信息)，他说使用concurrent.futures的话因为...

python 多进程【代码】

#方法一直接调用 import time import random from multiprocessing import Process def run(name):index = 0for i in range(3):print('%s runing' %name)time.sleep(random.randrange(1,5))print('%s running end' %name)index +1l = [] if __name__ == "__main__":for i in range(20):p = Process(target=run,args=(i,))p.start()l.append(p)for proc in l:proc.join()print("执行完毕")原文：https://www.cnblogs.com/asia9847/...

python多进程，并获取每个进程的返回值【代码】

pool = multiprocessing.Pool(processes=10) row = [...] for row in rows:task_id = row[1]img_id = row[0]pool.apply_async(check_picture_contain_human_or_dog, (task_id, img_id)) pool.close() pool.join() 原文：https://www.cnblogs.com/tanghuang/p/9786052.html

Python多进程机制实例详解【代码】

本文实例讲述了Python多进程机制。分享给大家供大家参考。具体如下：在以前只是接触过PYTHON的多线程机制，今天搜了一下多进程，相关文章好像不是特别多。看了几篇，小试了一把。程序如下，主要内容就是通过PRODUCER读一个本地文件，一行一行的放到队列中去。然后会有相应的WORKER从队列中取出这些行。 import multiprocessing import os import sys import Queue import time def writeQ(q,obj):q.put(obj,True,None)print "put s...

Python多进程并发(multiprocessing)

A manager returned by Manager() will support types list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Queue, Value and Array. For example,from multiprocessing import Process, Managerdef f(d, l): d[1] = ‘1‘ d[‘2‘] = 2 d[0.25] = None l.reverse()if __name__ == ‘__main__‘: manager = Manager() d = manager.dict() l = manager.list(range(10)) p...

Python 多进程编程之multiprocessing--Process【代码】

Python 多进程编程之multiprocessing1,Process跨平台的进程创建模块(multiprocessing), 支持跨平台:windowx/linux创建和启动创建格式:p=Process(target=函数名)----def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):group:分组(基本不用)target:表示这个进程实例所调用的对象.name:给进程起一个别名args:参数,表示调用对象的位置参数元组kwargs:表示调用对象的关键字参数字典注意:target后是函数...

PYTHON - 技术教程分类

Python3 教程 Python3 简介 Python3 环境搭建 Python3 基础语法 Python3 基本数据类型 Python3 解释器 Python3 注释 Python3 运算符 Python3 数字(Number) Python3 字符串 Python3 列表 Python3 元组 Python3 字典 Python3 集合 Python3 编程第一步 Python3 条件控制 Python3 循环语句 Python3 迭代器与生成器 Python3 函数 Python3 数据结构 Python3 模块 Python3 输入和输出 Python3 File Python3 OS Python3 错误和异常 Python3 面向对象 Python3 命名空间/作用域 Python3 标准库概览 Python3 实例 Python3 CGI编程 Python3 MySQL(PyMySQL) Python3 网络编程 Python3 SMTP发送邮件 Python3 多线程 Python3 日期和时间 Python3 内置函数 Python3 MongoDB Python3 urllib python 全部

PYTHON - 最热教程

python如何统计字符串中字母个数？使用Python进行微信公众号开发（三）回...Python+PyQT5的子线程更新UI界面的实例 python时间戳怎么获得？如何获得当前时...vscode调试python时提示无法将“conda”...python接口自动化全局变量access_token...python收取邮件(腾讯企业邮箱)python如何绘制降水图详解python并发获取snmp信息及性能测试...怎么卸载Python3.6？

首页 / PYTHON / Python中的多进程

Python中的多进程

内容导读

内容图文

1、Multiprocessing

2、进程池

3、多进程、多线程的选择

4、应用场景

、concurrent包

1、concurrent.futures

2、threadpoolexecutor对象

3、processpoolexector对象

4、支持上下文管理的调用

内容总结

内容备注

内容手机端

【Python中的多进程】教程文章相关的互联网学习教程文章

PYTHON - 技术教程分类

PYTHON - 最新教程

PYTHON - 最热教程