多进程multiprocess学习

最新推荐文章于 2024-05-20 09:47:45 发布
最新推荐文章于 2024-05-20 09:47:45 发布
阅读量288 收藏 1
点赞数
分类专栏： 线程，进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43955530/article/details/102995754
版权

计算机将任务平均的分配给不同的运算空间，可以提高运算速度，达到“多人同时处理任务” 的效果

1 创建multiprocess
创建process和thread如出一辙：

#进程和线程的import差不多
import multiprocessing as mp
import threading as td



def job(a,b):
    print('aaaaa')
    
#创建多进程的方法也和多线程差不多，job都是不加括号，加了括号代表调用函数，不加括号代表索引  
t1 = td.Thread(target = job,args = (1,2))
p1 = mp.Process(target = job,args = (1,2))

t1.start()
p1.start()

t1.join()
p1.join()

在IDLE和spyder的IDE直接运行会没有任何反应，需要到terminal中运行，转到py文件所在路径之后：python process.py就可以运行print的结果了

2 queue进程输出

import multiprocessing as mp

def job1(q):#multiprocess所做的job也是不能有return的值的
    result = 0
    for i in range(100):
        result = result + i
    print(result)
    q.put(result) #把运行出来的result放进q里面
    
def job2(q):
    result = 0
    for i in range(100):
        result = result + i**2
    print(result)
    q.put(result)

if __name__ == '__main__': #多进程一定要在这个main框架下运行不然会报错
    q = mp.Queue()
    #args如果只有一个值，也要写逗号，表示一个元组,用来表示参数的索引
    p1 = mp.Process(target = job1,args = (q,))   
    p2 = mp.Process(target = job2,args = (q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

这里分两次put进q里面，那么从q里面get的时候也可以get两次，第一次get第一次的结果，第二次get第二次的结果，第三次再想get 的时候就会出错：
在这里插入图片描述

import multiprocessing as mp

def job1(q):#multiprocess所做的job也是不能有return的值的
    result = 0
    for i in range(100):
        result = result + i
    q.put(result) #把运行出来的result放进q里面
    
def job2(q):
    result = 0
    for i in range(100):
        result = result + i**2
    print(result)
    q.put(result)

if __name__ == '__main__': #多进程一定要在这个main框架下运行不然会报错
    q = mp.Queue()
    #args如果只有一个值，也要写逗号，表示一个元组,用来表示参数的索引
    p1 = mp.Process(target = job1,args = (q,))   
    p2 = mp.Process(target = job2,args = (q,))
    
    p1.start()
    p2.start()
    
    
    p1.join()#等p1进行之后再进行后面的操作
    p2.join()#等p2进行之后再进行后面的操作
    #但是p1和p2的顺序不根据代码顺序，同时运行
    
    #哪个先得到结果，哪个就打印出来
    res1 = q.get()
    print(res1)
    res2 = q.get()
    print(res2)
    print(res1 + res2)

所以会出现两种结果：
在这里插入图片描述
在这里插入图片描述

3 效率问题

import multiprocessing as mp
import threading as td
import time

num = 600000

def job1(q):#multiprocess所做的job也是不能有return的值的
    result = 0
    for i in range(num):
        result = result + i
    q.put(result) #把运行出来的result放进q里面
    
def job2(q):
    result = 0
    for i in range(num):
        result = result + i**2
    q.put(result)
    
def job3(q):
    result = 0
    for i in range(num):
        result = result + i**3
    q.put(result)


#这是一个双进程，分别完成一部分任务，再合起来的效果   
def multicore():
    q1 = mp.Queue()
    #args如果只有一个值，也要写逗号，表示一个元组,用来表示参数的索引
    p1 = mp.Process(target = job1,args = (q1,))   
    p2 = mp.Process(target = job2,args = (q1,))
    p3 = mp.Process(target = job3,args = (q1,))
    
    p1.start()
    p2.start()
    p3.start()
    
    
    p1.join()#等p1进行之后再进行后面的操作
    p2.join()#等p2进行之后再进行后面的操作
    p3.join()
    #但是p1和p2的顺序不根据代码顺序，同时运行
    
    #哪个先得到结果，哪个就打印出来
    res1 = q1.get()
    res2 = q1.get()
    res3 = q1.get()
    print('multicore result: ',res1 + res2 + res3)

#这是一个单进程，一个人完成两部分计算任务的效果    
def normal():
    res = 0
    for i in range(num):
        res = res + i
    for i in range(num):
        res = res + i**2
    for i in range(num):
        res = res + i**3
    print('normal result: ',res)
    
#这是一个多线程，多个线程，执行一个计算任务
def multithread():
    q2 = mp.Queue() #多进程中的q放进多线程中也是可以的
    #args如果只有一个值，也要写逗号，表示一个元组,用来表示参数的索引
    t1 = td.Thread(target = job1,args = (q2,))   
    t2 = td.Thread(target = job2,args = (q2,))
    t3 = td.Thread(target = job3,args = (q2,))
    
    t1.start()
    t2.start()
    t3.start()
    
    
    t1.join()#等p1进行之后再进行后面的操作
    t2.join()#等p2进行之后再进行后面的操作
    t3.join()
    #但是p1和p2的顺序不根据代码顺序，同时运行
    
    #哪个先得到结果，哪个就打印出来
    res1 = q2.get()
    res2 = q2.get()
    res3 = q2.get()
    print('multithread result: ',res1 + res2 + res3)
    
if __name__ == '__main__':
    t = time.time() #记录此时的时间
    normal()
    t1 = time.time() #计算完normal的时间
    print('normal time:',t1-t)
    multithread() 
    t2 = time.time() #计算完multithread的时间
    print('multithread time:',t2-t1)
    multicore()
    t3 = time.time() #计算multicore的时间
    print('multicore time:',t3-t2)

在这里插入图片描述
可以看到多线程似乎还没有单线程的速度快，而多进程就比较快了，并且这个差距随着运算量变大越来越明显，比方说num再增大num = 10000000
在这里插入图片描述
在这里插入图片描述
但是当运算量较小时，多进程就起不到什么效果，甚至还没有但进程快：num = 1000时

在这里插入图片描述

4 进程池pool
进程池有两种用法：map和apply_async

map：
把所有的要运行的东西放入进程池里面，python会帮你分配进程

import multiprocessing as mp

def job(x):
    return x*x
#如果用mp.Process,job就不能有返回值，只能用进程队列取出来运行结果
#如果有进程池了，那么就可以有返回值

def multicore():
    #1 定义一个pool
    pool = mp.Pool()
    #2 往pool里面放入你的方程和要运算的值，等待自动分配进程和核
    res = pool.map(job,range(100000000))
    #3 返回得到的结果
    print(res)
    
if __name__ == '__main__':
    multicore()

可以看到八个核每个核都满载运转
在这里插入图片描述
修改mp.Pool()的参数可以指定占用多少个核，但是我指定了之后，IDE就闪退了…

apply_async:

import multiprocessing as mp

def job(x):
    return x*x
#如果用mp.Process,job就不能有返回值，只能用进程队列取出来运行结果
#如果有进程池了，那么就可以有返回值

def multicore():
    '''
    map相当于是自己一次性把任务自动分给多个进程做运算
    '''
    #1 定义一个pool
    pool = mp.Pool(processes = 8) #用到八个核
    #2 往pool里面放入你的方程和要运算的值，等待自动分配进程和核
    res = pool.map(job,range(10))
    #3 返回得到的结果
    print(res)
    
    '''
    apply_async相当于是一次运算一个值，分给一个进程算
    '''
    res = pool.apply_async(job,(2,)) #传入一个值被一个核运算
    #如果要传入多个值，会报错
    print(res.get()) #从res里面拿出来结果
    
    #如果要传入很多个值，每次用一个进程做运算，要用到迭代器
    multi_res = [pool.apply_async(job,(i,)) for i in range(10)]
    print([res.get() for res in multi_res])#再一个一个从列表中拿出来
    
if __name__ == '__main__':
    multicore()

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
4
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

5 共享内存
多线程共享变量，直接用global就可以了，但是在多进程里面，进程之间变量的交流存在于不同cpu之间，global是行不通的，只能用shared memory

import multiprocessing as mp
#共享内存的变量设置
value = mp.Value('d',1)#定义一个double型的1
array = mp.Array('i',[1,2,3,4])#定义一个不同于numpy的列表，不能是多维的，只能是一维的

6 Lock
现在随便写一段多进程处理同一个任务的代码，看它们之间是怎么竞争完成这些任务的计算的

import multiprocessing as mp
import time

def job(v,num,q):#做一个循环的操作    
    for _ in range(10):
        time.sleep(0.1)
        v.value += num  #共享内存的摄取值形式一定要是**.value
        q.put(v.value)

def multicore():
    q = mp.Queue()
    v = mp.Value('i',0) #定义一个共享内存的变量v
    p1 = mp.Process(target = job,args = (v,1,q))
    p2 = mp.Process(target = job,args = (v,3,q))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    
    res = 0
    for _ in range(20):
        res = q.get()
        print(res)



if __name__ == '__main__':
    multicore()

在这里插入图片描述
这样打印出来的东西很乱
因为两个进程在抢夺这个共享内存的值，有的时候就会出现重叠
如果想要两个进程分开进行，就要添加lock锁

import multiprocessing as mp
import time

def job(v,num,q):#做一个循环的操作    
    for _ in range(10):
        time.sleep(0.1)
        v.value += num  #共享内存的摄取值形式一定要是**.value
        q.put(v.value)

def multicore():
    q = mp.Queue()
    v = mp.Value('i',0) #定义一个共享内存的变量v
    p1 = mp.Process(target = job,args = (v,1,q))
    p2 = mp.Process(target = job,args = (v,3,q))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    
    res = 0
    for _ in range(20):
        res_pre = res
        res = q.get()
        if (res-res_pre) == 1:
            print('p1 is working...:',res)
        elif(res-res_pre) == 3:
            print('p2 is working...',res)
        else:
            print('...')
        
    print('multicore end')

def job2(v,num,q,l):#做一个循环的操作   
    l.acquire()
    for _ in range(10):
        time.sleep(0.1)
        v.value += num  #共享内存的摄取值形式一定要是**.value
        q.put(v.value)
    l.release()

def multicore_lock():
    l = mp.Lock()
    q2 = mp.Queue()
    v2 = mp.Value('i',0) #定义一个共享内存的变量v
    p1 = mp.Process(target = job2,args = (v2,1,q2,l))
    p2 = mp.Process(target = job2,args = (v2,3,q2,l))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
    
    res = 0
    for _ in range(20):
        res_pre = res
        res = q2.get()
#        print(res)
        if (res-res_pre) == 1:
            print('p1 is working...:',res)
        elif(res-res_pre) == 3:
            print('p2 is working...',res)
        else:
            print('...')
        
    
    print('multicore_lock end')


if __name__ == '__main__':
    t1 = time.time()
    multicore()   
    t2 = time.time()
    multicore_lock()
    t3 = time.time()
    print('multicore:',t2-t1)
    print('multicore_lock',t3-t1)

分别用不锁和锁的运行，看他们各自的运行情况和时间
p1 is working…: 1
p2 is working… 4
p1 is working…: 5
p2 is working… 8
p1 is working…: 9
p2 is working… 12
p1 is working…: 13
p2 is working… 16
p1 is working…: 17
p2 is working… 20
p1 is working…: 21
p2 is working… 24
p1 is working…: 25
p2 is working… 28
p1 is working…: 29
p2 is working… 32
p1 is working…: 33
p2 is working… 36
p1 is working…: 37
p2 is working… 40
multicore end
p1 is working…: 1
p1 is working…: 2
p1 is working…: 3
p1 is working…: 4
p1 is working…: 5
p1 is working…: 6
p1 is working…: 7
p1 is working…: 8
p1 is working…: 9
p1 is working…: 10
p2 is working… 13
p2 is working… 16
p2 is working… 19
p2 is working… 22
p2 is working… 25
p2 is working… 28
p2 is working… 31
p2 is working… 34
p2 is working… 37
p2 is working… 40
multicore_lock end
multicore: 1.2201902866363525
multicore_lock 3.403937339782715

进程锁保证了进程p1的完整运行，然后才进行了进程p2的运行

当然，也会出现不锁的时候是乱打印的情况，但是锁住的时候肯定是一个进程运行完之后，再运行另一个进程，锁住的过程不会有其他进程来捣乱
在这里插入图片描述

但是锁住之后，时间确实就变成了两倍，变成了串行的两个进程
在这里插入图片描述

逆夏11111
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python之Thread和multiprocessing
越努力越幸运
11-11 4716
下面的每个例子虽然都只给了代码，但是代码我都做了非常非常详细的注释，相信我们都能从其中得到知识的提升！~ 1.multithread_面向过程 import threading import time import os # a program to simulate selling tickets in multi-thread way # u may realize that this i
Python并发编程---多进程multiprocess（4）
deek的博客
11-22 476
Python并发编程—多进程multiprocess（4） 多进程日志 logging模块是线程安全的，不适合多进程日志，多进程日志需要再安装一个包concurrent_log_handler """多进程日志""" import logging from multiprocessing.pool import Pool import multiprocessing from concu
使用Multiprocess实现更强大的Python多进程处理
最新发布
gitblog_00055的博客
05-20 849
使用Multiprocess实现更强大的Python多进程处理 项目地址:https://gitcode.com/uqfoundation/multiprocess 项目简介 Multiprocess是Python标准库multiprocessing的一个增强版，它提供了更好的序列化支持，并使用dill扩展了功能。作为一个开源项目，Multiprocess是pathos框架的一部分，旨在为异构计算...
Python——multiprocessing包的学习心得（进程池）
FANCHOU的专栏
11-05 1331
上一篇，已经说了multiprocessing包提供了进程池的概念。可以直接利用。这里，直接贴出代码简单说明一下就好。  代码如下： from module import IpCheck from module import MyLogger from multiprocessing import Pool import time,os def logger(filepath,lines
进程（multiprocess）、线程（threading）、协程
weixin_45370628的博客
01-11 193
进程（process） 什么是进程 进程是操作系统分配资源（CPU、内存等）的最小单元 一个运行的程序就是一个进程，一个应用程序至少包括1个进程，而1个进程包裹1个或多个线程 进程拥有自己的独立空间，因此进程之间数据不共享。 线程（thread） 什么是线程 线程是操作系统调度的最小单元，不能独立存在，依赖进程 一个进程可以由多个线程组成 线程之间共享进程的所有资源 ...
【进程线程】multiprocess和threading模块
一个甜甜的大橙子的博客
01-30 412
方法，让其不再接受新的进程申请。方法是为了让母进程阻塞。
Python多进程示例multiprocess.py
11-15
Python多进程示例multiprocess.py python中的多线程其实并不是真正的多线程，如果想要充分地使用多核CPU的资源，在 python中大部分情况需要使用多进程。Python提供了非常好用的多进程包multiprocessing， 只需要定义...
MultiProcess:多进程测试case
04-16
标题“MultiProcess:多进程测试case”表明我们将讨论的焦点是关于使用Java进行多进程测试的案例。多进程测试主要是为了验证在多个独立运行的程序实例之间如何正确交互，确保系统的稳定性和性能。在Java中，我们通常...
Python进程间通信multiprocess代码实例
09-17
Python的`multiprocessing`模块是用于创建...在编写多进程程序时，可以根据具体需求选择合适的通信方式，以实现更复杂的应用场景。记住，理解和掌握`multiprocessing`模块对于编写高并发、高性能的Python程序至关重要。
Python Multiprocessing多进程 使用tqdm显示进度条的实现
09-18
在Python编程中，当面临计算密集型任务时，单线程的执行方式可能无法充分利用多核CPU的优势，这时就需要引入多进程技术来提升程序的运行效率。Python的`multiprocessing`模块提供了创建多进程的功能，而`tqdm`库则...
Unity-MultiProcess-BuildPipeline：统一的多进程构建管道
02-06
Unity-MultiProcess-BuildPipeline多进程资源建设方案设计创建多组子工程进行并行重建在Windows下，通过使用mklink命令创建子工程的在OSX下，由于Unity不支持资产目录为符号链接，因此为子工程创建真实资产目录，...
python multiprocessing.Process与threading.Thread的区别以及多进程，多线程的一些使用方法
noblaker的博客
03-24 2445
在前置的学习过程中遇到了tensorflow的一些问题，就想着用进程或者线程来解决。但是使用过程中出现了不少bug，才有了本文 概述 Process跟Thread的一些区别如下（不一定全面，只是自己使用中总结的）： （下文中会分别用代码说明） 首先是内存共享的问题。Thread创建的子线程可以直接使用主线程的变量数据；而Process创建的子进程跟主进程是完全隔离的，如果要用到主进程的变量，就必须作为参数传入，即使将所需变量设置为global也无效（因为设置.
c++builder传递参数_python中multiprocess的参数共享与传递
weixin_39585761的博客
11-23 130
multiprocessing作为Python中多进程的模块，对于充分利用cpu来处理计算敏感型任务可以很大的提高效率。题外话：对于I/O敏感型的任务multithreading更加适合，具体可以参考相关文章。multiprocessing对于新人来说还算友好，但是随着使用的深入，就会发现还是有很多独特的机制需要去理解。对于一些机制之前的文章也有所介绍，可以参考：python 多进程map方法应用...
python multiprocess——多进程加速
饮冰学徒的日记
09-30 8771
文章目录1. 前言2. multiprocess详解2.1 Process2.2 Pool （进程池）写在最后名词解释参考 1. 前言 现在cpu动不动就是6核12进程，计算能力越来越强，但是我们真的都用上了么？在跑python代码时，请打开你的后台监控，看看python的CPU占比。如果不做特殊处理（排除你调用的库），很有可能你的代码最高只能占用100%，资源利用率低下。 还有另外一个故事，当你的计算复杂度很高的时候，比如处理某些大文件，如果你只用一个进程，很有可能得跑24小时，为了加速，你就得想办法把你
Python3多进程multiprocess学习
热门推荐
qhd1994的博客
04-09 1万+
由于Python存在GIL锁，对于多线程来说，这只是部分代码可以使用多CPU的优势，对于想全部使用多CPU的性能，让每一个任务都充分地使用CPU，那么使用多进程就是达到此目的，因为每个进程在Python里单独的GIL锁，这样就不会在不同进程之间进行了阻塞。因此，如果是需要使用大量CPU计算资源的需要，就应该使用多进程的方式。什么是全局解释器锁GILPython代码的执行由Python 虚拟机(也叫...
Python模块multiprocessing & 实现多进程并发
m0_61066945的博客
06-17 4497
Python高并发、Python子进程多任务、Python进程通信
python模块 multiprocess 多进程
爱死亡机器人
10-27 439
multiprocess提供了Process类，实现进程相关的功能。但是它基于fork机制，因此不被windows平台支持。想要在windows中运行，必须使用的方式，显然这只能用于调试和学习，不能用于实际环境。另外，在中你既可以import大写的Process，也可以import小写的process，这两者是完全不同的东西。这种情况在Python中很多，请一定要小心和注意。下面是一个简单的多进程例子，Process类的用法和Thread类几乎一模一样。
Python并发编程---多进程multiprocess（2）
deek的博客
11-19 493
Python并发编程—多进程multiprocess（2） 进程通信和数据共享 Pipe multiprocessing.Pipe([duplex]) 用于两个进程之间的连接，返回表示管道末端的 Connection 对象的对 (conn1, conn2)。 参数duplex默认为True，则管道是双工的，两边都能发送和结束，duplex为False，则管道是单向的，conn1只能用于接收，con...
使用multiprocess创建进程池对象，说明其原理
06-10
需要注意的是，multiprocess模块是Python标准库提供的一个多进程处理模块，它可以跨平台运行，并且提供了进程池、进程通信、进程同步等功能。使用multiprocess创建进程池对象可以方便地管理进程的创建、销毁和复用，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值