一篇文章搞懂Python进程的multiprocessing模块

multiprocessing模块

解释:综合的处理进程的包

multiprocess模块下的Process模块:和创建进程相关

创建一个进程

# 创建一个进程
from multiprocessing import Process  # 导入创建进程模块
def func():  # 定义一个函数
    print('我是一个进程')
​
if __name__ =='__main__':
    p = Process(target=func)  # 创建一个进程对象p = Process(target=func),target:目标函数名
    p.start()  # 知道执行start才有了进程
# 结果
# 我是一个进程

证明创建一个进程的方法

import os
from multiprocessing import Process  # 导入创建进程模块
def func():  # 定义一个函数
    print('子进程:', os.getpid())
    print('我是一个进程')
​
if __name__ =='__main__':
    p = Process(target=func)  # 创建一个进程对象p = Process(target=func),target:目标函数名
    print('主进程', os.getpid())
    p.start()  # 知道执行start才有了进程
    print('主进程', os.getpid())
# 结果
# 主进程 23756
# 主进程 23756
# 子进程: 17900
# 我是一个进程

上程序运行方法异步程序

import os  # 1
from multiprocessing import Process  # 2
def func():  # 3
    print('子进程:', os.getpid())
    print('我是一个进程')
​
if __name__ =='__main__':
    p = Process(target=func)  # 4
    print('主进程', os.getpid())  # 5
    p.start()  # 6  解释:只是告知操作系统我要创建程序(至于操作系统做不做我们无法控制)PS:异步
    print('主进程', os.getpid())  # 7
# 运行方法见标号

异步进程传参

# 异步进程传参
import os
from multiprocessing import Process
def func(exes):
    print('我是一个%s'%exes)
if __name__ =='__main__':
    p = Process(target=func, args=('name',))  # 注意进程传参必须是传一个元组,即时只有一个值也要写成(123,)形式
    print('我是第一顺序执行者')
    p.start()
# 结果:
# 我是第一顺序执行者
# 我是一个name
# PS这是一个异步程序

join介绍(阻塞)PS:主进程会阻塞在jion出等待子进程运行结束

# join介绍(阻塞)
from multiprocessing import Process
def func(exes):
    print('我是一个%s'%exes)
if __name__ =='__main__':
    p = Process(target=func, args=('name',))  # 注意进程传参必须是传一个元组,即时只有一个值也要写成(123,)形式
    p.start()
    p.join()  # 调用join方法:实际是一个阻塞,只有子进程结束才能继续执行:实际是变成同步程序了
    print('我是第一顺序执行者')
    
# 结果:
# 我是一个name
# 我是第一顺序执行者
# PS加上join变成同步程序

PS:在Windows操作系统中,创建进程的语句必须放在 if name =='__main__':下面

开启多个子进程

开启多进程方法(可for循环开启多个进程)

# 开启多进程方法
import os
from multiprocessing import Process
def func():
    print('子进程%s的主进程是%s' % (os.getpid(), os.getppid()))
if __name__ =='__main__':
    p1 = Process(target=func)
    p2 = Process(target=func)
    p3 = Process(target=func)
    p4 = Process(target=func)
    p1.start()
    p2.start()
    p3.start()
    p4.start()
    print('------主进程%s-------'% os.getpid())
​
# 结果:
# ------主进程2104-------
# 子进程13440的主进程是2104
# 子进程7576的主进程是2104
# 子进程11600的主进程是2104
# 子进程14832的主进程是2104

证明进程杂乱的方法

# 证明进程杂乱的方法
import time
import os
from multiprocessing import Process
def func(i):
    time.sleep(1)
    print('%d   子进程%s的主进程是%s' % (i, os.getpid(), os.getppid()))
if __name__ =='__main__':
    for i in range(10):
        p = Process(target=func, args=(i,))
        p.start()
    print('------主进程%s-------' % os.getpid())
​
# 结果:
# ------主进程12556-------
# 0   子进程23168的主进程是12556
# 2   子进程22832的主进程是12556
# 1   子进程15976的主进程是12556
# 3   子进程14344的主进程是12556
# 4   子进程8216的主进程是12556
# 8   子进程22960的主进程是12556
# 6   子进程17812的主进程是12556
# 5   子进程22932的主进程是12556
# 9   子进程4696的主进程是12556
# 7   子进程14492的主进程是12556
# 子进程的运行顺序是杂乱无章的 

控制先输出子进程再输出主进程方法

import time
import os
from multiprocessing import Process
def func(i):
    time.sleep(1)
    print('%d   子进程%s的主进程是%s' % (i, os.getpid(), os.getppid()))
if __name__ =='__main__':
    p_lst = []
    for i in range(10):
        p = Process(target=func, args=(i,))
        p.start()
        p_lst.append(p)  # 创建一个列表,将所有子进程地址装入列表中
    for j in p_lst:
        j.join()
    print('------主进程%s-------' % os.getpid())
​
# 结果:
# 3   子进程17612的主进程是23516
# 2   子进程18616的主进程是23516
# 1   子进程16812的主进程是23516
# 0   子进程21592的主进程是23516
# 5   子进程23480的主进程是23516
# 4   子进程18064的主进程是23516
# 6   子进程16284的主进程是23516
# 8   子进程4524的主进程是23516
# 7   子进程21924的主进程是23516
# 9   子进程13000的主进程是23516
# ------主进程23516-------
# 控制先运行子进程再运行主进程方法

创建进程的其他方法class方法

# 创建进程的其他方法class方法
import os
from multiprocessing import Process
class MyProcess(Process):  # PS:必须创建一个类(可以叫任何名字)但必须继承Process类
    def __init__(self, arg1, arg2, arg3):  # 传进子进程的方法
        super().__init__()  # PS:继承父类(Process)的init方法
        self.arg1 = arg1
        self.arg2 = arg2
        self.arg3 = arg3
    def run(self):  # PS:必须有一个run方法
        print('子进程:{} 参数是{} {} {}'.format(os.getpid(), self.arg1, self.arg2, self.arg3))
        self.work()  # 在子进程中调用work方法的方法
    def work(self):
        print('我是work方法', os.getpid())
​
if __name__ == '__main__':
    p = MyProcess(1, 2, 3)  # 传参方法
    p.start()  # 默认调用run方法
    p.work()  # work直接在主进程中调用,并没有在子进程中执行  是同步
    print('主进程%s' % os.getpid())
# 结果:
# 我是work方法 6220
# 主进程6220
# 子进程:18236 参数是1 2 3
# 我是work方法 18236
​
​
# 使用时注意:实例化MyProcess得到一个对象
# 使用对象调用start方法
# 传参直接在实例化对象的时候传参

守护进程daemon

定义:守护进程会随着主进程的代码执行结束而结束,不等待其他子进程结束;

如果行等待子进程完成(在主进程最后加join方法);

正常的子进程没有执行完的时候主进程要一直等着。

守护进程

import time
from multiprocessing import Process
def func():
    while True:
        time.sleep(1)
        print('过了一秒')
if __name__ == '__main__':
    p = Process(target=func)
    p.daemon = True  # 一定在开启进程之前设置
    p.start()
    for i in range(100):
        time.sleep(0.1)
        print('*' * i)
# 注意
# 守护进程要在start之前设置
# 守护进程中不能再开启子进程

进程的其他方法

进程两方法p.is_alive()/p.terminate()

# p.is_alive()  # 判断进程是否还活着True代表进程还在,False代表进程不在了
# p.terminate()  # 结束一个进程,但是这个进程不会立即被杀死(异步操作)
import time
from multiprocessing import Process
def func():
    print('子进程开始')
    time.sleep(5)
    print('子进程结束')
​
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(p.is_alive())  # 判断进程是否还活着True代表进程还在,False代表进程不在了
    time.sleep(1)
    p.terminate()  # 结束一个进程,但是这个进程不会立即被杀死(异步操作)
    print(p.is_alive())

进程两属性name/pid

# name:查看进程名字\为进程名重命名
# pid:查看进程id
# 函数中使用
import time
from multiprocessing import Process
def func():
    print('子进程开始')
​
if __name__ == '__main__':
    p = Process(target=func)
    p.start()
    print(p.name, p.pid)
    p.name = '重命名进程名'
    print(p.name)
# 结果:
# Process-1 16876
# 重命名进程名
# 子进程开始
​
# 类中使用
class MyProcess(Process):
    def run(self):
        print('子进程开始', self.name, self.pid)
​
if __name__ == '__main__':
    p = MyProcess()
    p.start()
# 结果
# 子进程开始 MyProcess-2 13684

锁Lock

作用:就是在并发编程中,保证数据安全

定义锁和使用锁

from multiprocessing import Lock
lock = Lock()  # 实例化一个锁
lock.acquire()  # 需要锁==拿钥匙
lock.release()  # 释放锁==还钥匙

使用锁

from multiprocessing import Lock
from multiprocessing import Process
​
def func(k, lock):
    lock.release()
    print(k)
    lock.acquire()
​
​
if __name__ == '__main__':
    lock = Lock()
    for i in range(10):
        p = Process(target=func, args=(i, lock))
        p.start()

信号量Semaphore

信号量应用

import time
import random
from multiprocessing import Process
from multiprocessing import Semaphore  # 导入信号量
​
def toilet(i, sem):
    sem.acquire()  # 需要锁==拿钥匙
    print('%d进厕所' % i)
    time.sleep(random.randint(1, 5))
    print('%d出厕所' % i)
    sem.release()  # 释放锁==还钥匙
if __name__ == '__main__':
    sem = Semaphore(4)  # 实例化信号量并定义钥匙数量
    for i in range(10):
        p = Process(target=toilet, args=(i, sem))
        p.start()

事件Event

事件基础

# 事件基础
from multiprocessing import Event  # 导入事件
e = Event()  # 实例化一个事件
e.set()  # 将标志变成非阻塞
e.wait()  # 刚实例化出的一个事件对象,默认的信号是阻塞信号
e.clear()  # 将标志又变成阻塞
PS:e.is_set() # 是否阻塞 True就是非阻塞, False就是阻塞

红绿灯事件

import time
import random
from multiprocessing import Event
from multiprocessing import Process
​
def traffic_car(e):  # 控制红绿灯
    while True:
        if e.is_set():
            time.sleep(3)
            print('红灯亮')
            e.clear()  # 绿变红
        else:
            time.sleep(3)
            print('绿灯亮')
            e.set()  # 红变绿
def car(i, e):
    e.wait()
    print('%s车通过' % i)
if __name__ == '__main__':
    e = Event()  # 立一个红绿灯
    tra = Process(target=traffic_car, args=(e,))  # 实例化一个进程
    tra.start()  # 启动一个进程来控制红绿灯
    for i in range(100):
        if i % 6 == 0:
            time.sleep(random.randint(1, 3))
        car_lll = Process(target=car, args=(i, e))  # 实例化一辆车
        car_lll.start()  # 启动车辆

队列Queue

1、进程之间通信,可以使用multiprocessing的Queue模块

2、队列有两种创建方式,第一种不传参数,这种队列没有长度限制,第二种传参数,创建一个有最大长度限制的队列q = Queue(3)

3、提供两种重要方法:put get

4、qsize 有的操作系统会报错,有时不准(查看队列大小)

5、通过队列可以实现主进程与子进程的通信, 子进程与子进程之间的通信

队列简单使用

from multiprocessing import Queue  # 引用队列
q = Queue()  # 实例化队列
q.put(1)  # 往队列放数据
print(q.get())  # 在队列中取数据

主进程与子进程之间的通信

from multiprocessing import Queue
from multiprocessing import Process
def q_put(q):
    q.put('hello')
if __name__ == '__main__':
    q = Queue()
    p = Process(target=q_put, args=(q,))
    p.start()
    print(q.get())
# 结果:
# hello

子进程与子进程之间的通信

from multiprocessing import Queue
from multiprocessing import Process
def q_put(q):
    q.put('hello')
def q_get(q):
    print(q.get())
if __name__ == '__main__':
    q = Queue()
    p = Process(target=q_put, args=(q,))
    p.start()
    p2 = Process(target=q_get, args=(q,))
    p2.start()
# 结果:
# hello
文源网络,仅供学习之用,如有侵权请联系删除。

在学习Python的道路上肯定会遇见困难,别慌,我这里有一套学习资料,包含40+本电子书,800+个教学视频,涉及Python基础、爬虫、框架、数据分析、机器学习等,不怕你学不会!
https://shimo.im/docs/JWCghr8... 《Python学习资料》

关注公众号【Python圈子】,优质文章每日送达。

评论

暂无评论