python Process

最新推荐文章于 2024-07-08 16:27:19 发布
最新推荐文章于 2024-07-08 16:27:19 发布
阅读量1.4k 收藏 2
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaomingming_y/article/details/99975432
版权
本文介绍了Python的multiprocessing模块，包括进程的join方法、Rlock锁以及进程间的通信。重点讨论了全局变量在进程间不可共享的问题，并详细讲解了队列的使用，如Queue的empty、full方法及put、get操作。通过实例展示了队列的先进先出原则，同时提醒了在处理队列满或空时可能遇到的问题及其解决方案。
摘要由CSDN通过智能技术生成

1、multiprocessing

def info(title):
    print(title)
    print(__name__)
    print('father',os.getpid())
    print('self',os.getpid())
    print('-------')

if __name__ == "__main__":  #除了创建的子进程和子进程调用的函数，其他的都是脚本进程
    # info ('hello')
    #创建一个进程调用函数
    P = multiprocessing.Process(target=info,args=('hello python',))
    P.start()
    P.join()  #和多线程一样，也是等待的意思
    print('hello word')  #若没有join则会独立运行

2、join

import multiprocessing
import os
import time


def info(title):
    print(title)
    time.sleep(2)
    print(__name__)
    print('father', os.getppid())
    print('self', os.getpid())
    print('--------')


if __name__ == "__main__":
    p1 = multiprocessing.Process(target=info,args=('A1',))
    p2 = multiprocessing.Process(target=info, args=('A2',))
    p3 = multiprocessing.Process(target=info, args=('A3',))
    p1.start()
    p2.start()
    p3.start()
    p1.join()
    p2.join()
    p3.join()
    """
     这里的join只是为了卡住主进程，使得三个进程都执行完毕再执行print
     这里很重要，以后多进程扫描文件需要完全等待几个进程全部执行完毕在汇总
    """
    print('all over')
    '''
    轮流执行
    p1.start()
    p1.join()
    p2.start()
    p2.join()
    p3.start()
    p3.join()
    '''

3、Rlock

import os
import multiprocessing
import time

"""
 多进程，并发，可能乱序并发执行（主要看系统如何处理）
 多进程加锁，挨个执行,也可能是乱序
"""
def showdata(lock, i):
    with lock:
        print(multiprocessing.current_process().name)
        time.sleep(2)
        print(i)


if __name__ == "__main__":
    lock = multiprocessing.RLock() # 创建锁
    for num in range(10):
        multiprocessing.Process(target=showdata, args=(lock, num)).start()

import multiprocessing



def A(lock, i):
    print(i)

if __name__ == "__main__":
    lock = multiprocessing.RLock()  
    for I in range(10):
        A(lock,i)

"""
0
1
2
3
4
5
6
7
8
9
"""

"""
进程是一个独立的状态，各个进程之间毫不相关
"""
import multiprocessing



def A(lock, i):
    with lock:
        print(i)


if __name__ == "__main__":
    lock = multiprocessing.RLock() 
    process_list = [] 
    for i in range(10):
        p = multiprocessing.Process(target=A, args=(lock, i))
        p.start()
        process_list.append(p)

    for p in process_list:
        p.join()
"""
0
1
2
3
4
5
6
7
8
9
"""

4、进程通信

import multiprocessing
import os

def func(conn):
	conn.send(['a', 'b', 'c'])   #发送数据
	print('func',os.getpid(),conn.recv())  #收到的数据
    conn.close()    #关闭
if __name__ =="__main__":
    conn_a, conn_b = multiprocessing.Pipe()  #创建一个管道，两个口
    #print(id(conn_a),id(conn_b))
    #print(tyoe(conn_a),type(conn_b)) # multiprocessing.connection.Connection
    
    #相当于进程中conn_a.send(['a', 'b', 'c']),发送给conn_b
    p = multiprocessing.process(target=func,args=(conn_a,)).start()
    conn_b.send([1, 2, 3])  #发送数据给conn_a
    print('main',os.getpid(),conn_b.recv())

案例：

"""
编写一个类似与机器人对话系统的程序（我的机器人叫球球）
"""
import multiprocessing

def M(conn):
    while 1:
        recv_ = conn.recv()
        print('球球收到:%s'%recv_)
        if recv_ == "你好":
            conn.send('我不好')
        elif recv_ == "今天天气咋样":
            conn.send('冷~')
        elif recv_ == "说我很优秀":
            conn.send('泥奏凯')
        else:
            conn.send('略略略')
            
def P(conn):
    y = 'y'
    while y != 'n':
        input_ = input('小白说:')
        conn.send(input_)
        print(conn.recv())

if __name__ == "__main__":
    conn_M,conn_P = multiprocessing.Pipe()
    p_M = multiprocessing.Process(target=M,args=(conn_M,))
    p_M.start()
    P(conn_P)
"""
"""
小白说:你好
球球收到:你好
我不好
小白说:可萨哈克
球球收到:可萨哈克
略略略
小白说:今天天气咋样
球球收到:今天天气咋样
冷~
小白说:说我很优秀
球球收到:说我很优秀
泥奏凯
小白说:卡卡卡
球球收到:卡卡卡
略略略
"""

5、全局变量不可以进程共享

import multiprocessing
import os
data = []

def List():
    global data
    data.append(1)
    data.append(2)
    data.append(3)
    print('',os.getpid(),data)

if __name__ == "__main__":
    p = multiprocessing.Process(target=List,args=()).start() #子进程
    data.append('a')   #脚本进程
    data.append('b')
    data.append('c')
    print('全局变量不共享\n',os.getpid(),data)
    """
     全局变量不共享
	 2292 ['a', 'b', 'c']
	 15580 [1, 2, 3]
    """

6、队列

import multiprocessing
import os

queue = multiprocessing.Queue()
# 注意队列只能单向，要么是父进程插入子进程取出，要么是子进程插入父进程取出

def func(myq):
    print(os.getpid())
    myq.put([1, 2, 3, 4])  # 子进程插入


if __name__ == '__main__':
    print(os.getpid())
    # queue.put(['a','b'])  # 这里若是脚本父进程先插入了，子进程就没法再插入了
    p = multiprocessing.Process(target=func, args=(queue,))
    p.start()
    print(queue.get())  # 脚本父进程取出

"""
9700
3236
[1, 2, 3, 4]
"""

先进先出，放一个取一个

import multiprocessing

def PUT(q):
    q.put(100)

def GET(q):
    print('GET',q.get())
    

if __name__ == '__main__':
    q = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=PUT, args=(q,))
    p2 = multiprocessing.Process(target=GET, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

"""
GET 100
"""
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
"""

import multiprocessing

def PUT(q):
    for i in range(10):
        q.put(100)

def GET(q):
    print('GET',q.get())
    

if __name__ == '__main__':
    q = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=PUT, args=(q,))
    p2 = multiprocessing.Process(target=GET, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

运行卡住

import multiprocessing
import time

def PUT(q):
    for i in range(10):
        time.sleep(1)
        q.put(100)

def GET(q):
    while 1:
        print('GET',q.get(timeout = 5))
    

if __name__ == '__main__':
    q = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=PUT, args=(q,))
    p2 = multiprocessing.Process(target=GET, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

若5秒没有进入，则全部崩掉，可以用try…except解决 ?注：加break，不然会停不下来，输出完成后一直输出结束语句

import multiprocessing
import time

def PUT(q):
    for i in range(10):
        time.sleep(1)
        q.put(100)

def GET(q):
    while 1:
        try:
            print('GET',q.get(timeout = 5))
        except:
            print('队列中在5秒之内已经无法获取元素')
            break
    

if __name__ == '__main__':
    q = multiprocessing.Queue()
    p1 = multiprocessing.Process(target=PUT, args=(q,))
    p2 = multiprocessing.Process(target=GET, args=(q,))
    p1.start()
    p2.start()
    p1.join()
    p2.join()
"""
GET 100
GET 100
GET 100
GET 100
GET 100
GET 100
GET 100
GET 100
GET 100
GET 100
队列中在5秒之内已经无法获取元素
"""

Queue.empty()
如果队列为空，返回 True ，否则返回 False 。如果 empty() 返回 True ，不保证后续调用的 put() 不被阻塞。类似的，如果 empty() 返回 False ，也不保证后续调用的 get() 不被阻塞。

Queue.full()
如果队列是满的返回 True ，否则返回 False 。如果 full() 返回 True 不保证后续调用的 get() 不被阻塞。类似的，如果 full() 返回 False 也不保证后续调用的 put() 不被阻塞。

Queue.put(item, block=True, timeout=None)
将 item 放入队列。如果可选参数 block 是 true 并且 timeout 是 None (默认)，则在必要时阻塞至有空闲插槽可用。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间没有可用的空闲插槽，将引发 Full 异常。反之 (block 是 false)，如果空闲插槽立即可用，则把 item 放入队列，否则引发 Full 异常 ( 在这种情况下，timeout 将被忽略)。

Queue.get(block=True, timeout=None)
从队列中移除并返回一个项目。如果可选参数 block 是 true 并且 timeout 是 None (默认值)，则在必要时阻塞至项目可得到。如果 timeout 是个正数，将最多阻塞 timeout 秒，如果在这段时间内项目不能得到，将引发 Empty 异常。反之 (block 是 false) , 如果一个项目立即可得到，则返回一个项目，否则引发 Empty 异常 (这种情况下，timeout 将被忽略)。

XBCSMMZ
关注
Python多进程（process）（一）进程和进程池
09-15 1581
在Python中因为有GIL的原因，线程能提供的并发效果并不理想，Python在多核上如果要释放并发的性能，更多的依靠多进程，我们会比线程更深入的去学习多进程。进程（Process），顾名思义，就是进行中的程序。。进程是资源分配的最小单元，也就是说每个进程都有其单独的内存空间。Unix/Linux系统通过fork系统调用创建一个进程，但是在Windows中并没有fork调用。但是别担心，Python中内置的的，我们可以。
python process返回值_python-process
weixin_39638464的博客
12-10 1581
1.fork程序执行到os.fork()时，操作系统会创建一个新的进程(子进程)，然后复制父进程的所有信息到子进程中然后父进程和子进程都会从fork()函数中得到一个返回值，在子进程中这个值一定是0，而父进程中是子进程的 id号多进程中，每个进程中所有数据(包括全局变量)都各有拥有一份，互不影响父进程、子进程执行顺序没有规律，完全取决于操作系统的调度算法(多次fork的执行顺序)在Unix/Lin...
Python内存释放问题
weixin_34326429的博客
10-10 686
在项目中遇到一个很糟糕的问题，运行一个Python服务脚本，把服务器跑死了，以前以为开的进程过多，进程中因批量处理，导致内存和交换分区耗光引起的。后来才发现，确实是内存和交换分区无空间导致的死机，但却不是因为多进程分析引起的。 从网上看了很多资料，相关信息并不多，最后确定是由于Python对大对象内存的释放引起的。在一个对象的引用计数减为0时，与该对象对应的析构函数就会被调用，但是要特别注意的是...
python中 获取到进程中得数据，并用json得方式输出出来，
最新发布
qq_33192454的博客
07-08 179
模块来获取指定进程的详细信息，并将所需的数据转换为JSON格式输出。python使用psutil 根据进程id获取到程序运行得信息，并将此进程得各个数据，使用json得方式输出，我需要这个进程中某一块得实际数据。命令来获取系统中运行的进程信息，然后将这些信息解析为字典列表。模块获取相应的进程信息，并以JSON格式输出。模块将数据转换为JSON格式输出。来执行命令并获取进程的输出，然后使用。将字典列表转换为JSON格式并输出。函数根据给定的进程ID和数据名称使用。来获取特定进程的特定信息。
Python基础之进程（Process）
热门推荐
PythonGo
08-27 6万+
进程是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。 狭义定义：进程是正在运行的程序的实例（an instance of a computer program that is...
Python Process_Manager
wjl__ai__的博客
07-13 198
【代码】Python Process_Manager。
python process参数_Python利用Gausian Process对Hyper-parameter进行调参
weixin_39587010的博客
12-10 193
导语在做模型的时候发现调参尤其是调Hyper-parameter真是惆怅T T……像Logistic Regression、SVM这类参数少的还能凭感觉手动调调，遇上Random Forest、AdaBoost这些参数多的咬着牙也能调出好结果，说到神经网络，那就真是无语泪先流了……是时候考虑如何才能高效调参了(握拳)！1. Grid Search顾名思义，Grid Search将所有参数划分成网格...
Python Process多进程实现过程
09-18
Python中的多进程是通过`multiprocessing`模块来实现的，该模块提供了类似多线程的接口，但在每个进程中运行的任务是完全独立的，因此每个进程都有自己的内存空间，可以实现真正的并行计算。多进程在处理CPU密集型...
python process参数_将参数传递给Scrapy python中的process.crawl
weixin_39611331的博客
12-10 1068
我想得到与此命令行相同的结果：scrapy crawl linkedin_anonymous -a first = James -a last = Bond -o output.json我的脚本如下：import scrapyfrom linkedin_anonymous_spider import LinkedInAnonymousSpiderfrom scrapy.crawler import...
Python进程Process模块-Python零基础入门教程.pdf
06-13
【Python进程Process模块】是Python中用于处理进程的模块，它是多进程编程的基础。在操作系统中，进程是对各种资源管理的单位，包括内存、网络接口等。一个进程可以包含多个子进程，每个进程都有自己的独立内存空间...
Python实现进程管理小工具 Process Manager
PYmili的博客
03-29 2783
使用Python的Tkinter库实现一个gui内置 psutil 库来查询，控制系统中的进程。这样我们就可以简单的控制系统进程，另外增加了杀死非系统进程的功能，当进程太杂乱就可以直接杀死所有进程。 1.实现代码 关于查找，杀死，查看详细信息。这些功能，我们完全可以用 psutil 库来实现。不得不说，psutil库真的很强大！缺点就是当系统用户权限不够时很多进程无法访问到。 查找所有进程信息 def Get_ALL_Process(): Process_message = {}
简单介绍python process模块
Free雅轩的博客
05-28 780
在python中大部分情况需要使用多进程，python提供了multiprocessing模块。multiprocessing模块的功能众多：支持子进程、通信和共享数据、执行不同形式的同步，提供了Process、Queue、Pipe、Lock等组件。本文将着重讲解process模块的使用 process模块 process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。 参数介绍： Process（group=None, target=None, name=None, args=(
Python 进程 manager进程管理器
一碗烈酒的博客
09-08 956
""" 使用Manager进程管理器 进行进程间的数据共享 支持类型 list, dict, Namespace, Lock, RLock, Semaphore, BoundedSemaphore, Condition, Event, Barrier, Queue, Value, Array """ from multiprocessing import Process, Manager, Lock def work(loc, data): with loc: data['co.
python-process
weixin_30896763的博客
06-09 70
1.fork 程序执行到os.fork()时，操作系统会创建一个新的进程（子进程），然后复制父进程的所有信息到子进程中 然后父进程和子进程都会从fork()函数中得到一个返回值，在子进程中这个值一定是0，而父进程中是子进程的 id号 多进程中，每个进程中所有数据（包括全局变量）都各有拥有一份，互不影响 父进程、子进程执行顺序没有规律，完全取决于操作系统的调度算法(多次fork的执行顺序...
Python process
screaming的博客
04-03 1803
进程通信 subprocess 执行程序，获取返回码或输出信息。 call: 返回 ExitCode。check_call: 如果 ExitCode = 0，抛出 CalledProcessError 异常。check_output: 返回输出信息。ExitCode = 0 抛出异常。 命令行参数可以用 shlex.split 分解成列表。 >>> from subpro
python 中 使用 subprocess 写出 ProcessManager
comedate的专栏
01-13 307
python 中 使用 subprocess 写出 ProcessManager
初试jmeter，使用os process执行python脚本
wang_lijun_mme的博客
06-02 626
本人一直都是使用python的，之前接触的项目接口也都是处理很慢，属于非CPU 密集型任务，python 的GIL影响并不大，python编写测试工具完全够用了。接口发送逻辑：每次请求需要发送一帧数据+参数，根据视频帧率，以25fps为例，每间隔40ms之后，发送下一帧，中间需要根据返回结果，调整入参。确定好入参 和 结果（响应时间，响应结果，响应返回码等。我直接选中了jmeter，之前接触的比较少，一直没有深入使用，这次刚好趁这次机会，揭开他的面纱。我提取了四个，响应时间，错误码，响应结果，总共的帧数。
python-Process
icanactnow
04-02 367
创建进程 方法1 from multiprocessing import Queue, Process import os import time def test(): time.sleep(2) print(f'这个进程运行test方法，进程号{os.getpid()}') if __name__ == '__main__': # 创建进程 p = Pr...
python process模块的使用简介
ayu6_1的博客
04-11 2752
process模块 process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。 参数介绍： Process（group=None, target=None, name=None, args=(), kwargs={}） ''' 1 group——参数未使用，值始终为None 2 target——表示调用对象，即子进程要执行的任务 3 args——表示调用对象的位置参数元组，args=(1,2,'egon',) 4 kwargs——表示调用对象的字典,kwargs={'name':'egon
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值